tapimo 0.19.0 → 0.20.0

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

@@ -215,6 +215,28 @@ describe('GET /addresses/:address/activities', () => {
     ).toBe(false)
   })
 
+  test('normalizes timestamp bounds to UTC and rejects an inverted window', () => {
+    expect(
+      Activities.schema.getAddressActivities.Query.parse({
+        'timestamp.from': '2026-10-22T10:00:00+02:00',
+        'timestamp.to': '2026-10-23T00:00:00Z',
+      }),
+    ).toMatchObject({
+      'timestamp.from': '2026-10-22T08:00:00.000Z',
+      'timestamp.to': '2026-10-23T00:00:00.000Z',
+    })
+    expect(
+      Activities.schema.getAddressActivities.Query.safeParse({ 'timestamp.from': '1761091200' })
+        .success,
+    ).toBe(false)
+    expect(
+      Activities.schema.getAddressActivities.Query.safeParse({
+        'timestamp.from': '2026-10-23T00:00:00Z',
+        'timestamp.to': '2026-10-22T00:00:00Z',
+      }).success,
+    ).toBe(false)
+  })
+
   test('validates valuation amount filters', () => {
     expect(
       Activities.schema.getAddressActivities.Query.parse({
@@ -292,6 +314,35 @@ describe('GET /addresses/:address/activities', () => {
     ).toBe(true)
   })
 
+  test('filters activities by inclusive block timestamp window', async () => {
+    const unfiltered = await activities(accounts.creator, { limit: '5' })
+    const pivot = unfiltered.data.at(-1)
+    expect(pivot).toBeDefined()
+    if (!pivot) return
+
+    const windowed = await activities(accounts.creator, {
+      'timestamp.from': pivot.timestamp,
+      'timestamp.to': pivot.timestamp,
+    })
+    expect(windowed.data.length).toBeGreaterThan(0)
+    expect(windowed.data.every((entry) => entry.timestamp === pivot.timestamp)).toBe(true)
+    expect(windowed.data.some((entry) => entry.id === pivot.id)).toBe(true)
+    expect(windowed.nextCursor).toBeNull()
+
+    // Nothing lands between whole seconds, and nothing predates the chain.
+    const seconds = Date.parse(pivot.timestamp)
+    const between = await activities(accounts.creator, {
+      'timestamp.from': new Date(seconds + 500).toISOString(),
+      'timestamp.to': new Date(seconds + 999).toISOString(),
+    })
+    expect(between.data).toEqual([])
+    const before = await activities(accounts.creator, {
+      'timestamp.to': '1970-01-01T00:00:00Z',
+    })
+    expect(before.data).toEqual([])
+    expect(before.nextCursor).toBeNull()
+  })
+
   test.skipIf(runtime.mode !== 'localnet')(
     'filters and paginates indexed transfers by inclusive raw amount',
     async () => {
@@ -1113,14 +1164,15 @@ describe('GET /transactions/:transactionHash/activities', () => {
         to: Tempo.accounts[1].address,
         token: Addresses.pathUsd,
       })
-      const zoneReader = {
-        ...TestApp.key,
-        id: 'key_inferred_zone',
-        scopes: [...TestApp.key.scopes, `zone:${runtime.zone.chainId}:read`],
-        token: 'secret_inferred_zone',
-      } satisfies TestApp.kvStore.Key
+      const zoneReader = TestApp.zoneReader(
+        { ...TestApp.key, id: 'key_inferred_zone', token: 'secret_inferred_zone' },
+        [runtime.zone.chainId],
+      )
+      const zoneDb = TestApp.database()
+      await TestApp.delegateZone(zoneDb, { chainIds: [runtime.zone.chainId] })
       const client = TestApp.client({
         auth: { keys: [zoneReader] },
+        db: zoneDb,
         zones: [zone],
       })
       let response = await client.v1.transactions[':transactionHash'].activities.$get(
@@ -1668,6 +1720,88 @@ describe('Activities.list classification', () => {
     expect(queries.filter((query) => query.includes('FROM Transfer')).length).toBeGreaterThan(0)
   })
 
+  test('resolves timestamp bounds to a block range on every candidate query', async () => {
+    const queries: string[] = []
+    const tidx = {
+      fetch: async ({ query }: { query: string }) => {
+        queries.push(query.replace(/\s+/g, ' ').trim())
+        if (query.includes('FROM blocks'))
+          return { rows: [{ num: query.includes('timestamp >=') ? 900 : 1000 }] }
+        // Reject the materialized scan so the decoded fallback is bounded too.
+        if (query.includes('WITH transfer_candidates'))
+          throw new core_Tidx.FetchRequestError(
+            'ClickHouse query failed: Code: 60. DB::Exception: Unknown table expression identifier token_transfers (UNKNOWN_TABLE)',
+            new Response(null, { status: 422 }),
+          )
+        return { rows: [] }
+      },
+    } as unknown as Parameters<typeof Activities.tidx>[0]['tidx']
+    const provider = Activities.tidx({ chainId: 4217, tidx })
+
+    const { rows } = await provider.fetchRows({
+      address: viewer,
+      cursor: Cursor.encode([101, 5]),
+      filter: {
+        timestamp: { from: '2026-10-22T08:00:00.000Z', to: '2026-10-23T00:00:00.000Z' },
+      },
+      limit: 2,
+    })
+
+    expect(rows).toEqual([])
+    expect(queries.map((query) => query.match(/WHERE .*?(?= ORDER BY| LIMIT)/g)))
+      .toMatchInlineSnapshot(`
+        [
+          [
+            "WHERE timestamp >= '2026-10-22T08:00:00.000Z'",
+          ],
+          [
+            "WHERE timestamp <= '2026-10-23T00:00:00.000Z'",
+          ],
+          [
+            "WHERE "from" = '0x1111111111111111111111111111111111111111' AND block_num >= 900 AND block_num <= 1000 AND block_num <= 101 AND (block_num < 101 OR idx < 5)",
+            "WHERE fee_payer = '0x1111111111111111111111111111111111111111' AND block_num >= 900 AND block_num <= 1000 AND block_num <= 101 AND (block_num < 101 OR tx_idx < 5)",
+          ],
+          [
+            "WHERE "to" = '0x1111111111111111111111111111111111111111' AND "from" != '0x1111111111111111111111111111111111111111' AND block_num >= 900 AND block_num <= 1000 AND (block_num < 101 OR (block_num = 101 AND tx_idx < 5))",
+            "WHERE "from" = '0x1111111111111111111111111111111111111111' AND "to" != '0x1111111111111111111111111111111111111111' AND block_num >= 900 AND block_num <= 1000 AND (block_num < 101 OR (block_num = 101 AND tx_idx < 5))",
+          ],
+          [
+            "WHERE "to" = '0x1111111111111111111111111111111111111111' AND "from" != '0x1111111111111111111111111111111111111111' AND block_num = 101 AND tx_idx < 5 AND block_num >= 900 AND block_num <= 1000",
+          ],
+          [
+            "WHERE "from" = '0x1111111111111111111111111111111111111111' AND "to" != '0x1111111111111111111111111111111111111111' AND block_num = 101 AND tx_idx < 5 AND block_num >= 900 AND block_num <= 1000",
+          ],
+          [
+            "WHERE "to" = '0x1111111111111111111111111111111111111111' AND "from" != '0x1111111111111111111111111111111111111111' AND block_num < 101 AND block_num >= 900 AND block_num <= 1000",
+          ],
+          [
+            "WHERE "from" = '0x1111111111111111111111111111111111111111' AND "to" != '0x1111111111111111111111111111111111111111' AND block_num < 101 AND block_num >= 900 AND block_num <= 1000",
+          ],
+        ]
+      `)
+  })
+
+  test('skips candidate queries when no block falls inside the timestamp window', async () => {
+    const queries: string[] = []
+    const tidx = {
+      fetch: async ({ query }: { query: string }) => {
+        queries.push(query.replace(/\s+/g, ' ').trim())
+        return { rows: [] }
+      },
+    } as unknown as Parameters<typeof Activities.tidx>[0]['tidx']
+    const provider = Activities.tidx({ chainId: 4217, tidx })
+
+    const { rows } = await provider.fetchRows({
+      address: viewer,
+      filter: { timestamp: { from: '2999-01-01T00:00:00.000Z' } },
+      limit: 2,
+    })
+
+    expect(rows).toEqual([])
+    expect(queries.every((query) => query.includes('FROM blocks'))).toBe(true)
+    expect(queries).toHaveLength(1)
+  })
+
   test('skips hydration when no candidates match', async () => {
     const queries: string[] = []
     const tidx = {

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

@@ -151,8 +151,7 @@ export namespace schema {
         ),
       sourceAmount: SourceAmount,
       sourceToken: Token.check(z.describe('Token that moved in the transfer.')),
-      timestamp: z
-        .iso.datetime()
+      timestamp: Schema.dateTime()
         .check(z.describe('Block timestamp for the transfer.'), z.meta({ examples: ['2024-01-01T00:00:00Z'] })), // prettier-ignore
       transactionHash: Schema.Hash.check(
         z.describe('Transaction hash that contains this transfer.'),
@@ -252,8 +251,7 @@ export namespace schema {
         z.describe('Log index for this activity within the block.'),
         z.meta({ examples: [3] }),
       ),
-    timestamp: z
-      .iso.datetime()
+    timestamp: Schema.dateTime()
       .check(z.describe('Block timestamp as an ISO 8601 string.'), z.meta({ examples: ['2024-01-01T00:00:00Z'] })), // prettier-ignore
     title: z
       .string()
@@ -1554,8 +1552,7 @@ export namespace schema {
           ],
         }),
       ),
-      timestamp: z
-        .iso.datetime()
+      timestamp: Schema.dateTime()
         .check(z.describe('Timestamp of the first item in the group, as an ISO 8601 string.'), z.meta({ examples: ['2024-01-01T00:00:00Z'] })), // prettier-ignore
       title: z
         .literal('Group')
@@ -1662,6 +1659,8 @@ export namespace schema {
         sender: z
           .optional(Schema.Address)
           .check(z.describe('Only include activities sent from this sender address.')),
+        'timestamp.from': Schema.timestampBound('activities', 'from'),
+        'timestamp.to': Schema.timestampBound('activities', 'to'),
         token: z
           .optional(Schema.TokenAddress)
           .check(
@@ -1715,6 +1714,16 @@ export namespace schema {
             path: ['valuation.amount.from'],
           },
         ),
+        z.refine(
+          (query) =>
+            query['timestamp.from'] === undefined ||
+            query['timestamp.to'] === undefined ||
+            query['timestamp.from'] <= query['timestamp.to'],
+          {
+            error: '`timestamp.from` must be less than or equal to `timestamp.to`.',
+            path: ['timestamp.from'],
+          },
+        ),
         z.describe(
           'Query parameters for the address activity request. This feed uses cursor pagination only because activity classification can fold a variable number of rows into each entry, so positional `page` pagination would not be stable.',
         ),
@@ -2323,8 +2332,30 @@ type QueryFilter<item extends UnenrichedItem = UnenrichedItem> = {
   refine?: ((items: readonly item[]) => Promise<item[]> | item[]) | undefined
 }
 
-/** Sound predicates an activity provider can apply before classification. */
-export type CandidateFilter = ActivityFilter
+/** Inclusive ISO-8601 bounds on a transaction's block timestamp. */
+export type TimestampBounds = {
+  /** Earliest block timestamp to include. */
+  from?: string | undefined
+  /** Latest block timestamp to include. */
+  to?: string | undefined
+}
+
+/** Inclusive block-number range a timestamp window resolves to. */
+type BlockRange = {
+  /** Lowest block number to include. */
+  from?: number | undefined
+  /** Highest block number to include. */
+  to?: number | undefined
+}
+
+/**
+ * Sound predicates an activity provider can apply before classification.
+ * Timestamp bounds are exact: every row of a transaction shares its block.
+ */
+export type CandidateFilter = ActivityFilter & {
+  /** Block timestamp window; the provider resolves it to a block range before querying. */
+  timestamp?: TimestampBounds | undefined
+}
 
 /** Internal group of rows that share a transaction hash. */
 type TxGroup = {
@@ -2440,9 +2471,21 @@ export function addresses(options: addresses.Options = {}) {
           ...(query.sender ? { sender: query.sender } : {}),
           ...(query.token ? { token: query.token } : {}),
         }
-        const candidate = Object.keys(activityFilter).length > 0 ? activityFilter : undefined
+        const filterByActivity = Object.keys(activityFilter).length > 0
+        const timestampBounds = {
+          ...(query['timestamp.from'] !== undefined ? { from: query['timestamp.from'] } : {}),
+          ...(query['timestamp.to'] !== undefined ? { to: query['timestamp.to'] } : {}),
+        }
+        const filterByTimestamp = Object.keys(timestampBounds).length > 0
+        const candidate: CandidateFilter | undefined =
+          filterByActivity || filterByTimestamp
+            ? {
+                ...activityFilter,
+                ...(filterByTimestamp ? { timestamp: timestampBounds } : {}),
+              }
+            : undefined
         const types = new Set(query.type)
-        const refine = types.size > 0 || candidate ? <item extends UnenrichedItem>(items: readonly item[]) => filterActivities({ filter: activityFilter, items: items.filter((item) => types.size === 0 || types.has(item.type)) }) : undefined // prettier-ignore
+        const refine = types.size > 0 || filterByActivity ? <item extends UnenrichedItem>(items: readonly item[]) => filterActivities({ filter: activityFilter, items: items.filter((item) => types.size === 0 || types.has(item.type)) }) : undefined // prettier-ignore
         const listed = await Timing.time(c, 'address_activities', async () => {
           if (!query.include.includes('zones')) {
             const result = await Store.memoize(
@@ -2490,7 +2533,7 @@ export function addresses(options: addresses.Options = {}) {
                   },
                 ),
               {
-                key: `activities:v5:${chainId}:${address.toLowerCase()}:${query.type.join(',')}:${query['amount.from'] ?? ''}:${query['amount.to'] ?? ''}:${query.recipient ?? ''}:${query.sender ?? ''}:${query.token ?? ''}:${query['valuation.amount.from'] ?? ''}:${query['valuation.amount.to'] ?? ''}:${query['valuation.currency'] ?? ''}:${query.group ?? false}:${query.logs ?? false}:${query.cursor ?? 'head'}:${query.limit}`,
+                key: `activities:v6:${chainId}:${address.toLowerCase()}:${query.type.join(',')}:${query['amount.from'] ?? ''}:${query['amount.to'] ?? ''}:${query.recipient ?? ''}:${query.sender ?? ''}:${query.token ?? ''}:${query['timestamp.from'] ?? ''}:${query['timestamp.to'] ?? ''}:${query['valuation.amount.from'] ?? ''}:${query['valuation.amount.to'] ?? ''}:${query['valuation.currency'] ?? ''}:${query.group ?? false}:${query.logs ?? false}:${query.cursor ?? 'head'}:${query.limit}`,
                 store: c.get('store'),
                 ttl: Ttl.seconds(15),
               },
@@ -2545,7 +2588,7 @@ export function addresses(options: addresses.Options = {}) {
                 time: (name, fn) => Timing.sum(c, name, fn),
               }),
             {
-              key: `activities:zones:v6:${chainIds.join(',')}:${address.toLowerCase()}:${query.type.join(',')}:${query['amount.from'] ?? ''}:${query['amount.to'] ?? ''}:${query.recipient ?? ''}:${query.sender ?? ''}:${query.token ?? ''}:${query['valuation.amount.from'] ?? ''}:${query['valuation.amount.to'] ?? ''}:${query['valuation.currency'] ?? ''}:${query.group ?? false}:${query.logs ?? false}:${query.cursor ?? 'head'}:${query.limit}`,
+              key: `activities:zones:v7:${chainIds.join(',')}:${address.toLowerCase()}:${query.type.join(',')}:${query['amount.from'] ?? ''}:${query['amount.to'] ?? ''}:${query.recipient ?? ''}:${query.sender ?? ''}:${query.token ?? ''}:${query['timestamp.from'] ?? ''}:${query['timestamp.to'] ?? ''}:${query['valuation.amount.from'] ?? ''}:${query['valuation.amount.to'] ?? ''}:${query['valuation.currency'] ?? ''}:${query.group ?? false}:${query.logs ?? false}:${query.cursor ?? 'head'}:${query.limit}`,
               store: c.get('store'),
               ttl: Ttl.seconds(15),
             },
@@ -2975,6 +3018,7 @@ type AddressActivityTimingName =
   | 'address_activity_mpp'
   | 'address_activity_outbound'
   | 'address_activity_transfers'
+  | 'address_activity_window'
 
 type AddressActivityTime = <value>(
   name: AddressActivityTimingName,
@@ -3292,13 +3336,61 @@ export function tidx(deps: tidx.Deps): Provider {
     return { blockNum: decoded[0] as number, txIdx: decoded[1] as number }
   }
 
+  /**
+   * Resolves a timestamp window to the indexed blocks it spans, so every candidate
+   * scan can stop at a `block_num` floor. `null` means no indexed block falls inside it.
+   */
+  async function queryBlockRange(bounds: TimestampBounds): Promise<BlockRange | null> {
+    const blockNumber = (result: { rows: Record<string, unknown>[] }) =>
+      Value.toNumber(result.rows[0]?.['num'])
+    const [from, to] = await time('address_activity_window', () =>
+      Promise.all([
+        bounds.from === undefined
+          ? undefined
+          : fetch({
+              chainId,
+              query: `
+                SELECT num
+                FROM blocks
+                WHERE timestamp >= '${bounds.from}'
+                ORDER BY num ASC
+                LIMIT 1
+              ` as string,
+            }).then(blockNumber),
+        bounds.to === undefined
+          ? undefined
+          : fetch({
+              chainId,
+              query: `
+                SELECT num
+                FROM blocks
+                WHERE timestamp <= '${bounds.to}'
+                ORDER BY num DESC
+                LIMIT 1
+              ` as string,
+            }).then(blockNumber),
+      ]),
+    )
+    if (bounds.from !== undefined && from === undefined) return null
+    if (bounds.to !== undefined && to === undefined) return null
+    if (from !== undefined && to !== undefined && from > to) return null
+    return {
+      ...(from !== undefined ? { from } : {}),
+      ...(to !== undefined ? { to } : {}),
+    }
+  }
+
   /** Q1 selects bounded outbound transactions, then reads their logs. */
   async function queryOutbound(options: {
     address: Address.Address
     cursor: { blockNum: number; txIdx: number } | undefined
     limit: number
+    range: BlockRange | undefined
   }): Promise<Row[]> {
-    const { address, cursor, limit } = options
+    const { address, cursor, limit, range } = options
+    const window = blockRangePredicates(range)
+      .map((predicate) => `AND ${predicate}`)
+      .join(' ')
     const receiptKeyset = cursor
       ? `AND block_num <= ${cursor.blockNum} AND (block_num < ${cursor.blockNum} OR tx_idx < ${cursor.txIdx})`
       : ''
@@ -3315,13 +3407,13 @@ export function tidx(deps: tidx.Deps): Provider {
           WITH outbound_candidates AS (
             (SELECT hash AS tx_hash, block_num, block_timestamp, idx AS tx_idx, "from", fee_payer
              FROM txs
-             WHERE "from" = '${address}' ${txKeyset}
+             WHERE "from" = '${address}' ${window} ${txKeyset}
              ORDER BY block_num DESC, idx DESC
              LIMIT ${queryLimit})
             UNION
             (SELECT tx_hash, block_num, block_timestamp, tx_idx, "from", fee_payer
              FROM receipts
-             WHERE fee_payer = '${address}' ${receiptKeyset}
+             WHERE fee_payer = '${address}' ${window} ${receiptKeyset}
              ORDER BY block_num DESC, tx_idx DESC
              LIMIT ${queryLimit})
           )
@@ -3415,8 +3507,9 @@ export function tidx(deps: tidx.Deps): Provider {
     cursor: { blockNum: number; txIdx: number } | undefined
     filter: CandidateFilter | undefined
     limit: number
+    range: BlockRange | undefined
   }): Promise<Row[]> {
-    const { address, cursor, filter, limit } = options
+    const { address, cursor, filter, limit, range } = options
     const keyset = cursor
       ? `AND (block_num < ${cursor.blockNum} OR (block_num = ${cursor.blockNum} AND tx_idx < ${cursor.txIdx}))`
       : ''
@@ -3428,6 +3521,7 @@ export function tidx(deps: tidx.Deps): Provider {
     const materializedPredicate = [
       ...participantPredicates,
       ...(filter?.token !== undefined ? [`token = '${filter.token}'`] : []),
+      ...blockRangePredicates(range),
       ...(amount?.from !== undefined
         ? amount.from > maxTokenAmount
           ? ['0']
@@ -3442,6 +3536,7 @@ export function tidx(deps: tidx.Deps): Provider {
     const decodedPredicate = [
       ...participantPredicates,
       ...(filter?.token !== undefined ? [`address = '${filter.token}'`] : []),
+      ...blockRangePredicates(range),
       ...(amount?.from !== undefined
         ? amount.from > maxTokenAmount
           ? ['0']
@@ -3680,9 +3775,11 @@ export function tidx(deps: tidx.Deps): Provider {
     },
     async fetchRows({ address, cursor, filter, limit }) {
       const parsed = cursor ? parseCursor(cursor) : undefined
+      const range = filter?.timestamp ? await queryBlockRange(filter.timestamp) : undefined
+      if (range === null) return { rows: [] }
       const [q1, q2] = await Promise.all([
-        queryOutbound({ address, cursor: parsed, limit }),
-        queryTransfers({ address, cursor: parsed, filter, limit }),
+        queryOutbound({ address, cursor: parsed, limit, range }),
+        queryTransfers({ address, cursor: parsed, filter, limit, range }),
       ])
       return { rows: mergeAndSort(q1, q2, []) }
     },
@@ -3703,6 +3800,15 @@ export declare namespace tidx {
   }
 }
 
+/** Builds inclusive `block_num` predicates for a candidate query. */
+function blockRangePredicates(range: BlockRange | undefined): string[] {
+  if (!range) return []
+  return [
+    ...(range.from !== undefined ? [`block_num >= ${range.from}`] : []),
+    ...(range.to !== undefined ? [`block_num <= ${range.to}`] : []),
+  ]
+}
+
 /**
  * Merges three sub-query results into one `(blockNum desc, txIdx desc)` stream.
  * Q2/Q3 rows whose hash already appears in Q1 are dropped (Q1 rows are richer),

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

@@ -281,7 +281,11 @@ export namespace schema {
         'valuation.currency': getAddressBalances.Query.shape['valuation.currency'],
         verified: getAddressBalances.Query.shape.verified,
       })
-      .check(z.describe('Query parameters for listing token balances across accounts.'))
+      .check(
+        // Preserve the published parameter shape; the transform still enforces the existing address-count validation.
+        z.meta({ required: [] }),
+        z.describe('Query parameters for listing token balances across accounts.'),
+      )
 
     /** Balances held by one requested address. */
     export const AddressBalances = OpenApi.component(

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

@@ -25,7 +25,7 @@ const blockTags = ['latest', 'finalized'] as const
  * route's param schema (validation + OpenAPI `date-time` format) and
  * {@link parseBlockIdentifier} (runtime dispatch) so the two cannot drift.
  */
-const blockTimestamp = z.iso.datetime({ offset: true })
+const blockTimestamp = Schema.dateTime({ offset: true })
 
 /** Zod schemas owned by the block handlers. */
 export namespace schema {
@@ -194,12 +194,10 @@ export namespace schema {
           z.describe('Size of the block in bytes.'),
           z.meta({ examples: [1024] }),
         ),
-      timestamp: z.iso
-        .datetime()
-        .check(
-          z.describe('Block timestamp formatted as ISO 8601.'),
-          z.meta({ examples: ['2024-01-01T00:00:00Z'] }),
-        ),
+      timestamp: Schema.dateTime().check(
+        z.describe('Block timestamp formatted as ISO 8601.'),
+        z.meta({ examples: ['2024-01-01T00:00:00Z'] }),
+      ),
       transactionCount: z
         .number()
         .check(
@@ -242,12 +240,10 @@ export namespace schema {
           z.describe('The block height, starting from genesis block 0.'),
           z.meta({ examples: [23456789] }),
         ),
-      timestamp: z.iso
-        .datetime()
-        .check(
-          z.describe('Block timestamp formatted as ISO 8601.'),
-          z.meta({ examples: ['2024-01-01T00:00:00Z'] }),
-        ),
+      timestamp: Schema.dateTime().check(
+        z.describe('Block timestamp formatted as ISO 8601.'),
+        z.meta({ examples: ['2024-01-01T00:00:00Z'] }),
+      ),
       transactionCount: z
         .number()
         .check(

package/src/apps/data/routes/earn-transactions.local.test.ts

@@ -52,7 +52,9 @@ const privateClient = createClient({
   chain,
   transport: zoneHttp(runtime.zone.publicZoneUrl, { store }),
 })
-const key = { ...TestApp.key, scopes: ['data:read', `zone:${runtime.zone.chainId}:read`] }
+const key = TestApp.zoneReader({ ...TestApp.key, scopes: ['data:read'] }, [runtime.zone.chainId])
+/** Holds the key's organization delegation for the Zone. */
+const db = TestApp.database()
 let stack: Awaited<ReturnType<typeof EarnLocal.deploy>>
 let zone: Awaited<ReturnType<typeof EarnLocal.getZone>>
 let app: ReturnType<typeof TestApp.create>
@@ -64,8 +66,10 @@ beforeAll(async () => {
   zone = await EarnLocal.getZone({ client: parent, zoneId })
   await EarnLocal.enableZoneTokens({ client: administrator, portal: zone.portal, stack })
   await Actions.zone.signAuthorizationToken(privateClient, { store, zoneId })
+  await TestApp.delegateZone(db, { chainIds: [runtime.zone.chainId] })
   app = TestApp.create({
     auth: { keys: [key] },
+    db,
     zones: [
       TestApp.zone({
         chainId: runtime.zone.chainId,
@@ -159,6 +163,7 @@ describe('GET /v1/earn/transactions/:senderTag', () => {
       let unavailable = true
       const degraded = TestApp.create({
         auth: { keys: [key] },
+        db,
         logger: (entry) => {
           entries.push(entry)
         },

package/src/apps/data/routes/earn-transactions.test.ts

@@ -15,11 +15,14 @@ const query = new URLSearchParams({
   chainId: String(runtime.zone.chainId),
 })
 const endpoint = `/v1/earn/transactions/0x${'11'.repeat(32)}?${query}`
-const reader = { ...TestApp.key, scopes: ['data:read', `zone:${runtime.zone.chainId}:read`] }
+const reader = TestApp.zoneReader({ ...TestApp.key, scopes: ['data:read'] }, [runtime.zone.chainId])
+/** Holds the reader's organization delegation for the Zone. */
+const db = TestApp.database()
+await TestApp.delegateZone(db, { chainIds: [runtime.zone.chainId] })
 const headers = { 'tempo-api-key': reader.token }
 
 describe('GET /v1/earn/transactions/:senderTag', () => {
-  test('requires a matching Zone scope', async () => {
+  test('requires a delegated Zone tag', async () => {
     const response = await TestApp.create({ zones, auth: { keys: [TestApp.key] } }).request(
       endpoint,
       {
@@ -31,7 +34,7 @@ describe('GET /v1/earn/transactions/:senderTag', () => {
   })
 
   test('validates the sender tag, action id, and chain id', async () => {
-    const app = TestApp.create({ zones, auth: { keys: [reader] } })
+    const app = TestApp.create({ zones, auth: { keys: [reader] }, db })
     for (const field of ['actionId', 'chainId']) {
       const invalid = new URLSearchParams(query)
       invalid.delete(field)
@@ -51,6 +54,7 @@ describe('GET /v1/earn/transactions/:senderTag', () => {
     const app = TestApp.create({
       zones,
       auth: { keys: [reader] },
+      db,
       logger: (entry) => {
         entries.push(entry)
       },

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

@@ -28,20 +28,6 @@ const vaultQueries = [
   'include=zone',
 ] as const
 
-const collectionQueries = ['capability=deposit', ...vaultQueries] as const
-
-QueryBench.bench({
-  name: 'getEarnVaults',
-  path: '/v1/earn/vaults',
-  queries: collectionQueries,
-})
-
-QueryBench.bench({
-  name: 'getVerifiedEarnVaults',
-  path: '/v1/earn/vaults/verified',
-  queries: collectionQueries,
-})
-
 QueryBench.bench({
   name: 'getEarnAddressPositions',
   path: {

package/src/apps/data/routes/earn.discovery.test.ts

@@ -18,7 +18,6 @@ import {
 import * as TestApp from '../../../../test/App.js'
 import * as TestEarn from '../../../../test/Earn.js'
 import * as Runtime from '../../../../test/runtime.js'
-import * as Cursor from '../../../internal/Cursor.js'
 import * as Earn from './earn.js'
 
 const abi = parseAbi([
@@ -27,7 +26,6 @@ const abi = parseAbi([
 const share = '0x20c00000000000000000000075d0f7d57b571b8a'
 const asset = '0x20c0000000000000000000000000000000000001'
 const factory = '0xb4944264260a6412351d64653f65d2c27d9cb038'
-const foreignFactory = '0x5b972d2490d06e436982fab77612fd9987f097d0'
 const attacker = '0x1111111111111111111111111111111111111111'
 
 let url: string
@@ -156,36 +154,6 @@ repair_derived_on_startup = false
     expect(BigInt(result.data[0]!.shareAmount.amount)).toBeGreaterThan(0n)
   })
 
-  test.each([attacker, foreignFactory] as const)(
-    'rejects deployment logs from %s before filtering and pagination',
-    async (address) => {
-      await insert({
-        address,
-        asset: zeroAddress,
-        blockNumber: 101,
-        vault: TestEarn.activeEarningsVaultAddress,
-      })
-      await insert({ address, blockNumber: 102, vault: TestEarn.vaultAddress })
-      const cursor = Cursor.encode([101, 0])
-      const response = await app.request(
-        `/v1/earn/vaults?chainId=42431&asset=${asset}&cursor=${encodeURIComponent(cursor)}&limit=5`,
-      )
-      expect(response.status, await response.clone().text()).toBe(200)
-      const result = await TestApp.json(response, Earn.schema.getEarnVaults.Response)
-      expect({ ids: result.data.map((vault) => vault.id), nextCursor: result.nextCursor }).toEqual({
-        ids: [TestEarn.activeEarningsVaultAddress],
-        nextCursor: null,
-      })
-      const unfiltered = await app.request('/v1/earn/vaults?chainId=42431&limit=5')
-      expect(unfiltered.status).toBe(200)
-      const page = await TestApp.json(unfiltered, Earn.schema.getEarnVaults.Response)
-      expect({ ids: page.data.map((vault) => vault.id), nextCursor: page.nextCursor }).toEqual({
-        ids: [TestEarn.activeEarningsVaultAddress],
-        nextCursor: null,
-      })
-    },
-  )
-
   test('returns no indexed discoveries on an unconfigured chain', async () => {
     const app = TestApp.create({
       auth: false,
@@ -194,14 +162,11 @@ repair_derived_on_startup = false
       supportedChainIds: [1337],
       tidx: { baseUrl: 'http://127.0.0.1:1' },
     })
-    for (const path of [
-      '/v1/earn/vaults',
+    const response = await app.request(
       `/v1/earn/addresses/${TestEarn.activeEarningsAddress}/positions`,
-    ]) {
-      const response = await app.request(path)
-      expect(response.status, await response.clone().text()).toBe(200)
-      expect(await response.json()).toEqual({ data: [], nextCursor: null })
-    }
+    )
+    expect(response.status, await response.clone().text()).toBe(200)
+    expect(await response.json()).toEqual({ data: [], nextCursor: null })
   })
 })