tapimo 0.19.0 → 0.20.0

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

@@ -30,11 +30,6 @@ import * as Earn from './earn.js'
 const cache = { edge: false, store: Store.memory() } as const
 
 /** Fields every vault read enriches with live state, value, and rate data. */
-type EnrichedVault = Pick<
-  z.output<typeof Earn.schema.Vault>,
-  'apy' | 'instantLiquidity' | 'sharePrice' | 'state' | 'tvl'
->
-
 type OpenApiSchema = { $ref?: string }
 
 type OpenApiOperation = {
@@ -528,12 +523,10 @@ describe('GET /v1/earn/rewards/eligibility', () => {
       rpcUrl: 'https://mainnet-zone.example',
       sourceChainId: Viem.chainId.mainnet,
     })
-    const key = {
-      ...readKey,
-      environment: 'sandbox',
-      scopes: [...readKey.scopes, `zone:${zone.id}:read`],
-    } satisfies TestApp.kvStore.Key
-    const response = await TestApp.create({ auth: { keys: [key] }, zones: [zone] }).request(
+    const key = TestApp.zoneReader({ ...readKey, environment: 'sandbox' }, [zone.id])
+    const db = TestApp.database()
+    await TestApp.delegateZone(db, { chainIds: [zone.id], environment: 'sandbox', orgId: key.orgId }) // prettier-ignore
+    const response = await TestApp.create({ auth: { keys: [key] }, db, zones: [zone] }).request(
       `/v1/earn/rewards/eligibility?chainId=${zone.id}&vaultAddress=${vaultAddress}`,
       { headers: { authorization: `Bearer ${key.token}` } },
     )
@@ -546,12 +539,10 @@ describe('GET /v1/earn/rewards/eligibility', () => {
       chainId: 421_700_001,
       rpcUrl: 'https://unknown-zone.example',
     })
-    const key = {
-      ...readKey,
-      environment: 'sandbox',
-      scopes: [...readKey.scopes, `zone:${zone.id}:read`],
-    } satisfies TestApp.kvStore.Key
-    const response = await TestApp.create({ auth: { keys: [key] }, zones: [zone] }).request(
+    const key = TestApp.zoneReader({ ...readKey, environment: 'sandbox' }, [zone.id])
+    const db = TestApp.database()
+    await TestApp.delegateZone(db, { chainIds: [zone.id], environment: 'sandbox', orgId: key.orgId }) // prettier-ignore
+    const response = await TestApp.create({ auth: { keys: [key] }, db, zones: [zone] }).request(
       `/v1/earn/rewards/eligibility?chainId=${zone.id}&vaultAddress=${vaultAddress}`,
       { headers: { authorization: `Bearer ${key.token}` } },
     )
@@ -606,12 +597,12 @@ describe('GET /v1/earn/rewards/eligibility', () => {
     })
   })
 })
-describe('schema.getEarnVaults.Query', () => {
+describe('schema.VaultCollectionQuery', () => {
   test('parses collection filters', () => {
-    const query = Earn.schema.getEarnVaults.Query.parse({
+    const query = Earn.schema.VaultCollectionQuery.parse({
       capability: 'deposit,exactWithdraw',
       'engine.type': 'erc4626',
-      include: 'access,apy,capabilities,zone,zones,token.logoUri,tvl',
+      include: 'access,capabilities,zone,zones,token.logoUri',
       limit: '10',
     })
 
@@ -619,37 +610,37 @@ describe('schema.getEarnVaults.Query', () => {
     expect(query['engine.type']).toBe('erc4626')
     expect(query.include).toStrictEqual([
       'access',
-      'apy',
       'capabilities',
       'zone',
       'zones',
       'token.logoUri',
-      'tvl',
     ])
     expect(query.limit).toBe(10)
   })
 
   test('defaults the page size', () => {
-    expect(Earn.schema.getEarnVaults.Query.parse({}).limit).toBe(10)
+    expect(Earn.schema.VaultCollectionQuery.parse({}).limit).toBe(10)
   })
 
   test('rejects obsolete and detail-only parameters', () => {
-    expect(() => Earn.schema.getEarnVaults.Query.parse({ 'engine.kind': 'erc4626' })).toThrow()
-    expect(() => Earn.schema.getEarnVaults.Query.parse({ status: 'live-demo' })).toThrow()
+    expect(() => Earn.schema.VaultCollectionQuery.parse({ 'engine.kind': 'erc4626' })).toThrow()
+    expect(() => Earn.schema.VaultCollectionQuery.parse({ status: 'live-demo' })).toThrow()
     expect(() =>
       Earn.schema.getEarnVault.Query.parse({
         gateway: '0x0000000000000000000000000000000000000001',
       }),
     ).toThrow()
   })
+})
 
-  test('accepts every selectable rate window across every vault read', () => {
+describe('schema.getEarnVault.Query', () => {
+  test('accepts every selectable rate window', () => {
     expect([
       // An omitted window stays absent, so no rate is measured.
-      Earn.schema.getEarnVaults.Query.parse({})['apy.window'],
-      Earn.schema.getEarnVaults.Query.parse({ 'apy.window': '1h' })['apy.window'],
-      Earn.schema.getEarnVaults.Query.parse({ 'apy.window': '1d' })['apy.window'],
-      Earn.schema.getVerifiedEarnVaults.Query.parse({ 'apy.window': '7d' })['apy.window'],
+      Earn.schema.getEarnVault.Query.parse({})['apy.window'],
+      Earn.schema.getEarnVault.Query.parse({ 'apy.window': '1h' })['apy.window'],
+      Earn.schema.getEarnVault.Query.parse({ 'apy.window': '1d' })['apy.window'],
+      Earn.schema.getEarnVault.Query.parse({ 'apy.window': '7d' })['apy.window'],
       Earn.schema.getEarnVault.Query.parse({ 'apy.window': '30d' })['apy.window'],
     ]).toStrictEqual([undefined, '1h', '1d', '7d', '30d'])
   })
@@ -1407,249 +1398,18 @@ describe('discoveryBatchLimit', () => {
   })
 })
 
-describe('GET /v1/earn/vaults/verified', () => {
-  test('registers the static verified path before the vault path', async () => {
+describe('vault lists', () => {
+  test('are not served', async () => {
     const app = TestApp.create({ auth: false, cache })
-    const response = await app.request('/v1/earn/vaults/verified')
+    const [all, verified] = await Promise.all([
+      app.request('/v1/earn/vaults'),
+      app.request('/v1/earn/vaults/verified'),
+    ])
 
-    expect(response.status).toBe(200)
-    expect(await TestApp.json(response, Earn.schema.getVerifiedEarnVaults.Response)).toStrictEqual({
-      data: [],
-      nextCursor: null,
-    })
+    expect(all.status).toBe(404)
+    expect(verified.status).toBe(400)
+    expect((await TestApp.json(verified, Schema.ErrorResponse)).error.code).toBe('vault_id_invalid')
   })
-
-  test.runIf(Runtime.get().mode === 'testnet')(
-    'returns null for an inaccessible legacy Zone route',
-    async () => {
-      const db = TestApp.database()
-      await core_EarnVaults.upsert(db, {
-        ...TestEarn.zoneVerifiedVault,
-        privateInputTokens: [TestEarn.assetTokenAddress],
-        privateOutputTokens: [TestEarn.assetTokenAddress],
-        zones: [],
-      })
-      const zone = {
-        ...TestEarn.zone,
-        contracts: {
-          ...TestEarn.zone.contracts,
-          earnRouter: { address: TestEarn.zoneRoute.earnRouter },
-        },
-      }
-      const app = TestApp.create({ auth: false, cache, db, zones: [zone] })
-      const query = `chainId=${TestEarn.chain.id}&include=zone`
-      const [detail, list] = await Promise.all([
-        app.request(`/v1/earn/vaults/${TestEarn.zoneVaultAddress}?${query}`),
-        app.request(`/v1/earn/vaults/verified?${query}`),
-      ])
-
-      expect([detail.status, list.status]).toStrictEqual([200, 200])
-      expect((await TestApp.json(detail, Earn.schema.getEarnVault.Response)).zone).toBeNull()
-      expect(
-        (await TestApp.json(list, Earn.schema.getVerifiedEarnVaults.Response)).data[0]?.zone,
-      ).toBeNull()
-    },
-    90_000,
-  )
-
-  test.runIf(Runtime.get().mode === 'testnet')(
-    'returns curated fields for a public-only vault',
-    async () => {
-      const db = TestApp.database()
-      const record = await core_EarnVaults.upsert(db, TestEarn.verifiedVault)
-      const app = TestApp.create({ auth: false, cache, db, zones: [TestEarn.zone] })
-      const response = await app.request(
-        `/v1/earn/vaults/verified?chainId=${TestEarn.verifiedVault.chainId}&include=access,capabilities,zone&limit=5`,
-      )
-
-      expect(response.status).toBe(200)
-      const body = await TestApp.json(response, Earn.schema.getVerifiedEarnVaults.Response)
-      expect(body.nextCursor).toBeNull()
-      expect(body.data).toHaveLength(1)
-      const [vault] = body.data
-      expect(vault).toBeDefined()
-      if (!vault) return
-      expect(vault.slug).toBe(record.slug)
-      expect(vault).not.toHaveProperty('gateway')
-      // The rate and the valuation are include-gated, and neither was requested.
-      expect(vault).not.toHaveProperty('apy')
-      expect(vault).not.toHaveProperty('tvl')
-      const capabilities = vault.capabilities
-      expect(capabilities).toBeDefined()
-      if (!capabilities) return
-      expect({
-        access: vault.access,
-        assetTokenVerified: vault.assetToken.verified,
-        description: vault.description,
-        engine: vault.engine,
-        id: vault.id,
-        label: vault.label,
-        privateRouting: capabilities.privateRouting,
-        routerSwaps: capabilities.routerSwaps,
-        shareTokenVerified: vault.shareToken.verified,
-        vaultAddress: vault.vaultAddress,
-        verified: vault.verified,
-        zone: vault.zone,
-      }).toMatchInlineSnapshot(`
-        {
-          "access": {
-            "status": "allowlisted",
-          },
-          "assetTokenVerified": false,
-          "description": "Bridge test PATHUSD deposited into the canonical Earn v1 stack.",
-          "engine": {
-            "address": "0xd85fc943333a6cd7c0e3391acd54fc4e572f0baf",
-            "type": "erc4626",
-            "venue": "0xa8b4f0e69cd4b0e56b676343f02acd8c3b355322",
-          },
-          "id": "0xf4ae63687d6753a78e7f551d2eda1d0d31a5ea3a",
-          "label": "btPATHUSD Earn",
-          "privateRouting": false,
-          "routerSwaps": false,
-          "shareTokenVerified": false,
-          "vaultAddress": "0xf4ae63687d6753a78e7f551d2eda1d0d31a5ea3a",
-          "verified": true,
-          "zone": null,
-        }
-      `)
-    },
-    60_000,
-  )
-
-  test.runIf(Runtime.get().mode === 'testnet')(
-    'hides stale private fields without a configured router',
-    async () => {
-      const db = TestApp.database()
-      await core_EarnVaults.upsert(db, {
-        ...TestEarn.verifiedVault,
-        privateInputTokens: [TestEarn.assetTokenAddress],
-        privateOutputTokens: [TestEarn.assetTokenAddress],
-      })
-      const app = TestApp.create({ auth: false, cache, db, zones: [TestEarn.zone] })
-      const response = await app.request(
-        `/v1/earn/vaults/verified?chainId=${TestEarn.verifiedVault.chainId}&include=access,capabilities,zone&limit=5`,
-      )
-
-      expect(response.status).toBe(200)
-      const body = await TestApp.json(response, Earn.schema.getVerifiedEarnVaults.Response)
-      expect(body.data[0]).toMatchObject({
-        capabilities: { privateRouting: false, routerSwaps: false },
-        verified: true,
-        zone: null,
-      })
-      expect(body.data[0]).not.toHaveProperty('gateway')
-    },
-    60_000,
-  )
-
-  test.runIf(Runtime.get().mode === 'testnet')(
-    'reuses live discovery across public endpoints',
-    async () => {
-      const db = TestApp.database()
-      await core_EarnVaults.upsert(db, TestEarn.verifiedVault)
-      // Its own cache: the assertion needs a cold discovery followed by a warm one.
-      const app = TestApp.create({
-        auth: false,
-        cache: { edge: false, store: Store.memory() },
-        db,
-        zones: [TestEarn.zone],
-      })
-      const detail = await app.request(
-        `/v1/earn/vaults/${TestEarn.vaultAddress}?chainId=${TestEarn.chain.id}&include=access,capabilities,zone`,
-      )
-      const verified = await app.request(
-        `/v1/earn/vaults/verified?chainId=${TestEarn.chain.id}&include=access,capabilities,zone&limit=5`,
-      )
-
-      expect([detail.status, verified.status]).toStrictEqual([200, 200])
-      expect(detail.headers.get('server-timing')).toContain('earn_vault_discovery')
-      expect(verified.headers.get('server-timing')).not.toContain('earn_vault_discovery')
-    },
-    60_000,
-  )
-
-  test.runIf(Runtime.get().mode === 'testnet')(
-    'shares live enrichment across all three vault reads',
-    async () => {
-      const db = TestApp.database()
-      await core_EarnVaults.upsert(db, TestEarn.verifiedVault)
-      const app = TestApp.create({ auth: false, cache, db, zones: [TestEarn.zone] })
-      const cursor = Cursor.encode([
-        TestEarn.indexedDeployment.blockNumber,
-        TestEarn.indexedDeployment.logIndex,
-      ])
-      const query = `chainId=${TestEarn.chain.id}&apy.window=1h&include=tvl`
-      const [all, verified, detail] = await Promise.all([
-        app.request(`/v1/earn/vaults?${query}&cursor=${encodeURIComponent(cursor)}&limit=5`),
-        app.request(`/v1/earn/vaults/verified?${query}&limit=5`),
-        app.request(`/v1/earn/vaults/${TestEarn.vaultAddress}?${query}`),
-      ])
-
-      expect([all.status, verified.status, detail.status]).toStrictEqual([200, 200, 200])
-      for (const response of [all, verified, detail])
-        expect(response.headers.get('cache-control')).toBe(
-          'private, max-age=30, stale-while-revalidate=120',
-        )
-      const [allBody, verifiedBody, vault] = await Promise.all([
-        TestApp.json(all, Earn.schema.getEarnVaults.Response),
-        TestApp.json(verified, Earn.schema.getVerifiedEarnVaults.Response),
-        TestApp.json(detail, Earn.schema.getEarnVault.Response),
-      ])
-      const enriched = ({ apy, instantLiquidity, sharePrice, state, tvl }: EnrichedVault) => ({
-        apy,
-        instantLiquidity,
-        sharePrice,
-        state,
-        tvl,
-      })
-      const rows = [allBody, verifiedBody].map((body) =>
-        body.data.find((candidate) => candidate.id === vault.id),
-      )
-      expect(rows.every((row) => row !== undefined)).toBe(true)
-      // The window promotes the rate and `include` selects the valuation, so all
-      // three reads carry both fields.
-      expect(['apy' in vault, 'tvl' in vault]).toStrictEqual([true, true])
-      for (const row of rows) if (row) expect(enriched(row)).toStrictEqual(enriched(vault))
-      // Every asset on these pages is USD-denominated, so no rate was consulted.
-      expect([allBody.meta, verifiedBody.meta, vault.meta]).toStrictEqual([
-        undefined,
-        undefined,
-        undefined,
-      ])
-    },
-    90_000,
-  )
-
-  test.runIf(Runtime.get().mode === 'testnet')(
-    'applies the verified-vault address cursor',
-    async () => {
-      const db = TestApp.database()
-      const vaultAddresses = [
-        TestEarn.vaultAddress,
-        TestEarn.indexedDeployment.vaultAddress,
-      ] as const
-      for (const vaultAddress of vaultAddresses)
-        await core_EarnVaults.upsert(db, {
-          chainId: TestEarn.chain.id,
-          description: null,
-          label: 'Pagination vault',
-          privateInputTokens: [],
-          privateOutputTokens: [],
-          vaultAddress,
-          zones: [],
-        })
-      const app = TestApp.create({ auth: false, cache, db, zones: [TestEarn.zone] })
-      const cursor = Cursor.encode([TestEarn.indexedDeployment.vaultAddress])
-      const response = await app.request(
-        `/v1/earn/vaults/verified?chainId=${TestEarn.chain.id}&limit=5&cursor=${encodeURIComponent(cursor)}`,
-      )
-      expect(response.status).toBe(200)
-      const body = await TestApp.json(response, Earn.schema.getVerifiedEarnVaults.Response)
-      expect(body.data.map((vault) => vault.id)).toStrictEqual([TestEarn.vaultAddress])
-      expect(body.nextCursor).toBeNull()
-    },
-    90_000,
-  )
 })
 
 describe('GET /v1/earn/addresses/:address/positions', () => {
@@ -1705,13 +1465,13 @@ describe('GET /v1/earn/addresses/:address/positions', () => {
   })
 
   test('rejects Zone earnings includes', async () => {
-    const key = {
-      ...TestApp.key,
-      id: 'key_earn_zone_positions',
-      scopes: ['data:read', `zone:${TestEarn.zone.id}:read`],
-      token: 'secret_earn_zone_positions',
-    } satisfies TestApp.kvStore.Key
-    const app = TestApp.create({ auth: { keys: [key] }, cache, zones: [TestEarn.zone] })
+    const key = TestApp.zoneReader(
+      { ...TestApp.key, id: 'key_earn_zone_positions', scopes: ['data:read'], token: 'secret_earn_zone_positions' }, // prettier-ignore
+      [TestEarn.zone.id],
+    )
+    const db = TestApp.database()
+    await TestApp.delegateZone(db, { chainIds: [TestEarn.zone.id] })
+    const app = TestApp.create({ auth: { keys: [key] }, cache, db, zones: [TestEarn.zone] })
     const response = await app.request(
       `/v1/earn/addresses/${TestEarn.positionAddress}/positions?chainId=${TestEarn.zone.id}&include=earnings`,
       { headers: { 'tempo-api-key': key.token } },
@@ -1873,6 +1633,116 @@ describe('GET /v1/earn/vaults/:vaultId', () => {
     expect((await TestApp.json(response, Schema.ErrorResponse)).error.code).toBe('vault_id_invalid')
   })
 
+  test.runIf(Runtime.get().mode === 'testnet')(
+    'returns null for an inaccessible legacy Zone route',
+    async () => {
+      const db = TestApp.database()
+      await core_EarnVaults.upsert(db, {
+        ...TestEarn.zoneVerifiedVault,
+        privateInputTokens: [TestEarn.assetTokenAddress],
+        privateOutputTokens: [TestEarn.assetTokenAddress],
+        zones: [],
+      })
+      const zone = {
+        ...TestEarn.zone,
+        contracts: {
+          ...TestEarn.zone.contracts,
+          earnRouter: { address: TestEarn.zoneRoute.earnRouter },
+        },
+      }
+      const app = TestApp.create({ auth: false, cache, db, zones: [zone] })
+      const query = `chainId=${TestEarn.chain.id}&include=zone`
+      const response = await app.request(`/v1/earn/vaults/${TestEarn.zoneVaultAddress}?${query}`)
+
+      expect(response.status).toBe(200)
+      expect((await TestApp.json(response, Earn.schema.getEarnVault.Response)).zone).toBeNull()
+    },
+    90_000,
+  )
+
+  test.runIf(Runtime.get().mode === 'testnet')(
+    'returns a public-only verified vault without its curated branding',
+    async () => {
+      const db = TestApp.database()
+      await core_EarnVaults.upsert(db, TestEarn.verifiedVault)
+      const app = TestApp.create({ auth: false, cache, db, zones: [TestEarn.zone] })
+      const response = await app.request(
+        `/v1/earn/vaults/${TestEarn.verifiedVault.vaultAddress}?chainId=${TestEarn.verifiedVault.chainId}&include=access,capabilities,zone`,
+      )
+
+      expect(response.status).toBe(200)
+      const vault = await TestApp.json(response, Earn.schema.getEarnVault.Response)
+      // Registry labels name customers, so only the admin app serves them. `label` stays
+      // present but empty because existing clients require it.
+      for (const field of ['description', 'slug']) expect(vault).not.toHaveProperty(field)
+      expect(vault.label).toBe('')
+      expect(vault).not.toHaveProperty('gateway')
+      // The rate and the valuation are include-gated, and neither was requested.
+      expect(vault).not.toHaveProperty('apy')
+      expect(vault).not.toHaveProperty('tvl')
+      const capabilities = vault.capabilities
+      expect(capabilities).toBeDefined()
+      if (!capabilities) return
+      expect({
+        access: vault.access,
+        assetTokenVerified: vault.assetToken.verified,
+        engine: vault.engine,
+        id: vault.id,
+        privateRouting: capabilities.privateRouting,
+        routerSwaps: capabilities.routerSwaps,
+        shareTokenVerified: vault.shareToken.verified,
+        vaultAddress: vault.vaultAddress,
+        verified: vault.verified,
+        zone: vault.zone,
+      }).toMatchInlineSnapshot(`
+        {
+          "access": {
+            "status": "allowlisted",
+          },
+          "assetTokenVerified": false,
+          "engine": {
+            "address": "0xd85fc943333a6cd7c0e3391acd54fc4e572f0baf",
+            "type": "erc4626",
+            "venue": "0xa8b4f0e69cd4b0e56b676343f02acd8c3b355322",
+          },
+          "id": "0xf4ae63687d6753a78e7f551d2eda1d0d31a5ea3a",
+          "privateRouting": false,
+          "routerSwaps": false,
+          "shareTokenVerified": false,
+          "vaultAddress": "0xf4ae63687d6753a78e7f551d2eda1d0d31a5ea3a",
+          "verified": true,
+          "zone": null,
+        }
+      `)
+    },
+    60_000,
+  )
+
+  test.runIf(Runtime.get().mode === 'testnet')(
+    'hides stale private fields without a configured router',
+    async () => {
+      const db = TestApp.database()
+      await core_EarnVaults.upsert(db, {
+        ...TestEarn.verifiedVault,
+        privateInputTokens: [TestEarn.assetTokenAddress],
+        privateOutputTokens: [TestEarn.assetTokenAddress],
+      })
+      const app = TestApp.create({ auth: false, cache, db, zones: [TestEarn.zone] })
+      const response = await app.request(
+        `/v1/earn/vaults/${TestEarn.verifiedVault.vaultAddress}?chainId=${TestEarn.verifiedVault.chainId}&include=access,capabilities,zone`,
+      )
+
+      expect(response.status).toBe(200)
+      const vault = await TestApp.json(response, Earn.schema.getEarnVault.Response)
+      expect(vault).toMatchObject({
+        capabilities: { privateRouting: false, routerSwaps: false },
+        verified: true,
+        zone: null,
+      })
+      expect(vault).not.toHaveProperty('gateway')
+    },
+    60_000,
+  )
   test.runIf(Runtime.get().mode === 'testnet')(
     'resolves an unregistered vault directly from chain state',
     async () => {
@@ -1892,11 +1762,8 @@ describe('GET /v1/earn/vaults/:vaultId', () => {
       const included = await TestApp.json(includedResponse, Earn.schema.getEarnVault.Response)
       expect({
         access: included.access,
-        description: included.description,
         engineType: included.engine.type,
         id: included.id,
-        label: included.label,
-        slug: included.slug,
         vaultAddress: included.vaultAddress,
         verified: included.verified,
         zone: included.zone,
@@ -1905,11 +1772,8 @@ describe('GET /v1/earn/vaults/:vaultId', () => {
           "access": {
             "status": "allowlisted",
           },
-          "description": null,
           "engineType": "erc4626",
           "id": "0xf4ae63687d6753a78e7f551d2eda1d0d31a5ea3a",
-          "label": "Tempo Earn Live Vault (Earn)",
-          "slug": null,
           "vaultAddress": "0xf4ae63687d6753a78e7f551d2eda1d0d31a5ea3a",
           "verified": false,
           "zone": null,
@@ -2474,12 +2338,10 @@ describe('GET /v1/earn/vaults/:vaultId/share-prices', () => {
 })
 
 describe('GET /v1/earn/vaults/:vaultId/positions/:address', () => {
-  const zoneKey = {
-    ...TestApp.key,
-    id: 'key_earn_zone_vault_position',
-    scopes: ['data:read', `zone:${TestEarn.zone.id}:read`],
-    token: 'secret_earn_zone_vault_position',
-  } satisfies TestApp.kvStore.Key
+  const zoneKey = TestApp.zoneReader(
+    { ...TestApp.key, id: 'key_earn_zone_vault_position', scopes: ['data:read'], token: 'secret_earn_zone_vault_position' }, // prettier-ignore
+    [TestEarn.zone.id],
+  )
 
   test('accepts and validates the wallet APY include', () => {
     expect(Earn.schema.getEarnVaultPosition.Query.safeParse({ include: ['apy'] }).success).toBe(
@@ -2533,9 +2395,12 @@ describe('GET /v1/earn/vaults/:vaultId/positions/:address', () => {
   test.runIf(Runtime.get().mode === 'testnet')(
     'returns not found for an incompatible public parent vault selected through a Zone',
     async () => {
+      const db = TestApp.database()
+      await TestApp.delegateZone(db, { chainIds: [TestEarn.zone.id] })
       const response = await TestApp.create({
         auth: { keys: [zoneKey] },
         cache,
+        db,
         zones: [TestEarn.zone],
       }).request(
         `/v1/earn/vaults/${TestEarn.assetTokenAddress}/positions/${TestEarn.positionAddress}?chainId=${TestEarn.zone.id}`,
@@ -3390,168 +3255,6 @@ describe('GET /v1/earn/vaults/:vaultId/earnings/:address', () => {
   )
 })
 
-describe('GET /v1/earn/vaults', () => {
-  test.runIf(Runtime.get().mode === 'testnet')(
-    'extracts an indexed deployment and applies onchain filters',
-    async () => {
-      const db = TestApp.database()
-      const record = await core_EarnVaults.upsert(db, TestEarn.indexedVerifiedVault)
-      const app = TestApp.create({ auth: false, cache, db, zones: [TestEarn.zone] })
-      const query = new URLSearchParams({
-        asset: TestEarn.assetTokenAddress,
-        capability: 'deposit,exactWithdraw',
-        chainId: String(TestEarn.chain.id),
-        cursor: Cursor.encode([
-          TestEarn.indexedDeployment.blockNumber,
-          TestEarn.indexedDeployment.logIndex + 1,
-        ]),
-        'engine.type': 'erc4626',
-        limit: '5',
-      })
-      const response = await app.request(`/v1/earn/vaults?${query}`)
-
-      expect(response.status).toBe(200)
-      const timing = response.headers.get('server-timing') ?? ''
-      expect(timing).not.toContain('token_metadata')
-      expect(timing).not.toContain('token_logo')
-      // Neither the rate measurement nor the FX rate set is reached on a page
-      // that asked for neither.
-      expect(timing).not.toContain('earn_apy')
-      expect(timing).not.toContain('valuation_rates')
-      const body = await TestApp.json(response, Earn.schema.getEarnVaults.Response)
-      const vault = body.data.find(
-        (candidate) => candidate.vaultAddress === TestEarn.indexedDeployment.vaultAddress,
-      )
-      expect(vault).toBeDefined()
-      if (!vault) return
-      expect(vault.slug).toBe(record.slug)
-      expect(vault.assetToken).not.toHaveProperty('logoUri')
-      expect(vault.shareToken).not.toHaveProperty('logoUri')
-      expect(vault).not.toHaveProperty('gateway')
-      expect(vault).not.toHaveProperty('access')
-      expect(vault).not.toHaveProperty('apy')
-      expect(vault).not.toHaveProperty('capabilities')
-      expect(vault).not.toHaveProperty('tvl')
-      expect(vault).not.toHaveProperty('zone')
-
-      query.set('include', 'access,apy,capabilities,token.logoUri,tvl,zone')
-      const includedResponse = await app.request(`/v1/earn/vaults?${query}`)
-      expect(includedResponse.status).toBe(200)
-      const includedTiming = includedResponse.headers.get('server-timing') ?? ''
-      expect(includedTiming).toContain('token_logo')
-      expect(includedTiming).toContain('earn_apy')
-      expect(includedTiming).toContain('valuation_rates')
-      const includedBody = await TestApp.json(includedResponse, Earn.schema.getEarnVaults.Response)
-      const included = includedBody.data.find(
-        (candidate) => candidate.vaultAddress === TestEarn.indexedDeployment.vaultAddress,
-      )
-      expect(included).toBeDefined()
-      if (!included) return
-      expect(['apy' in included, 'tvl' in included]).toStrictEqual([true, true])
-      expect({
-        access: included.access,
-        assetToken: {
-          address: included.assetToken.address,
-          decimals: included.assetToken.decimals,
-          name: included.assetToken.name,
-          symbol: included.assetToken.symbol,
-        },
-        capabilities: included.capabilities,
-        description: included.description,
-        engine: included.engine,
-        id: included.id,
-        label: included.label,
-        shareToken: {
-          address: included.shareToken.address,
-          decimals: included.shareToken.decimals,
-          name: included.shareToken.name,
-          symbol: included.shareToken.symbol,
-        },
-        vaultAddress: included.vaultAddress,
-        verified: included.verified,
-      }).toMatchInlineSnapshot(`
-        {
-          "access": {
-            "status": "allowlisted",
-          },
-          "assetToken": {
-            "address": "0x20c000000000000000000000ff04042ee92fd449",
-            "decimals": 6,
-            "name": "Bridge Test PATHUSD",
-            "symbol": "btPATHUSD",
-          },
-          "capabilities": {
-            "asyncRedeem": false,
-            "boundedRedeem": true,
-            "deposit": true,
-            "exactWithdraw": true,
-            "inKindDeposit": true,
-            "privateRouting": false,
-            "redeem": true,
-            "routerSwaps": false,
-          },
-          "description": "Indexed Bridge Test PATHUSD Earn deployment.",
-          "engine": {
-            "address": "0x3bba4aa05eee3c6e568e0e60185a4eb630927928",
-            "type": "erc4626",
-            "venue": "0xa8b4f0e69cd4b0e56b676343f02acd8c3b355322",
-          },
-          "id": "0xd4a673d20aeac2773d340ed595c497d460663ca2",
-          "label": "Indexed btPATHUSD Earn",
-          "shareToken": {
-            "address": "0x20c0000000000000000000006ee48bc223de1c5b",
-            "decimals": 6,
-            "name": "Tempo Earn Live Vault (Earn)",
-            "symbol": "teLIVEE",
-          },
-          "vaultAddress": "0xd4a673d20aeac2773d340ed595c497d460663ca2",
-          "verified": true,
-        }
-      `)
-    },
-    60_000,
-  )
-
-  test.runIf(Runtime.get().mode === 'testnet')(
-    'traverses live indexed deployments from an opaque cursor',
-    async () => {
-      const app = TestApp.create({ auth: false, cache, zones: [TestEarn.zone] })
-      const cursor = Cursor.encode([
-        TestEarn.indexedDeployment.blockNumber,
-        TestEarn.indexedDeployment.logIndex,
-      ])
-      const response = await app.request(
-        `/v1/earn/vaults?chainId=${TestEarn.chain.id}&cursor=${encodeURIComponent(cursor)}&limit=5`,
-      )
-
-      expect(response.status).toBe(200)
-      const body = await TestApp.json(response, Earn.schema.getEarnVaults.Response)
-      expect({
-        ids: body.data.map((vault) => vault.id),
-        nextCursor: body.nextCursor,
-        valid: body.data.every(
-          (vault) =>
-            vault.vaultAddress === vault.id &&
-            vault.assetToken.address.startsWith('0x20c0') &&
-            vault.engine.address.startsWith('0x') &&
-            vault.shareToken.address.startsWith('0x20c0') &&
-            vault.slug === null &&
-            !vault.verified,
-        ),
-      }).toMatchInlineSnapshot(`
-        {
-          "ids": [
-            "0xf4ae63687d6753a78e7f551d2eda1d0d31a5ea3a",
-          ],
-          "nextCursor": null,
-          "valid": true,
-        }
-      `)
-    },
-    90_000,
-  )
-})
-
 describe('OpenAPI', () => {
   test('publishes stable Earn components', async () => {
     const app = TestApp.create({ auth: false, cache })
@@ -3589,14 +3292,6 @@ describe('OpenAPI', () => {
           "/v1/earn/vaults/{vaultId}/share-prices",
           "#/components/schemas/EarnVaultSharePriceList",
         ],
-        "getEarnVaults": [
-          "/v1/earn/vaults",
-          "#/components/schemas/EarnVaultList",
-        ],
-        "getVerifiedEarnVaults": [
-          "/v1/earn/vaults/verified",
-          "#/components/schemas/VerifiedEarnVaultList",
-        ],
       }
     `)
     expect(
@@ -3604,23 +3299,21 @@ describe('OpenAPI', () => {
         .filter((name) => name.startsWith('Earn') && !name.endsWith('Error'))
         .sort(),
     ).toMatchInlineSnapshot(`
-        [
-          "EarnAddressPosition",
-          "EarnAddressPositionList",
-          "EarnTransaction",
-          "EarnVault",
-          "EarnVaultDetail",
-          "EarnVaultEarnings",
-          "EarnVaultEngine",
-          "EarnVaultList",
-          "EarnVaultPosition",
-          "EarnVaultSharePriceList",
-          "EarnVaultZone",
-          "EarnVaultZoneRoute",
-        ]
-      `)
-    expect(spec.components?.schemas).toHaveProperty('VerifiedEarnVault')
-    expect(spec.components?.schemas).toHaveProperty('VerifiedEarnVaultList')
+      [
+        "EarnAddressPosition",
+        "EarnAddressPositionList",
+        "EarnTransaction",
+        "EarnVaultDetail",
+        "EarnVaultEarnings",
+        "EarnVaultEngine",
+        "EarnVaultPosition",
+        "EarnVaultSharePriceList",
+        "EarnVaultZone",
+        "EarnVaultZoneRoute",
+      ]
+    `)
+    expect(spec.paths).not.toHaveProperty('/v1/earn/vaults')
+    expect(spec.paths).not.toHaveProperty('/v1/earn/vaults/verified')
     expect(JSON.stringify(spec.components?.schemas?.['EarnAddressPosition'])).toContain(
       'An account’s position in one earn vault.',
     )
@@ -3629,17 +3322,9 @@ describe('OpenAPI', () => {
         spec.paths['/v1/earn/vaults/{vaultId}']?.get?.responses?.['400']?.content?.[
           'application/json'
         ]?.schema?.$ref,
-      list: spec.paths['/v1/earn/vaults']?.get?.responses?.['400']?.content?.['application/json']
-        ?.schema?.$ref,
-      verified:
-        spec.paths['/v1/earn/vaults/verified']?.get?.responses?.['400']?.content?.[
-          'application/json'
-        ]?.schema?.$ref,
     }).toMatchInlineSnapshot(`
       {
         "detail": "#/components/schemas/ApiKeyMalformedOrChainIdInvalidOrChainIdUnsupportedOrQueryInvalidOrVaultIdInvalidError",
-        "list": "#/components/schemas/ApiKeyMalformedOrChainIdInvalidOrChainIdUnsupportedOrQueryInvalidError",
-        "verified": "#/components/schemas/ApiKeyMalformedOrChainIdInvalidOrChainIdUnsupportedOrQueryInvalidError",
       }
     `)
   })
@@ -3647,15 +3332,13 @@ describe('OpenAPI', () => {
   test('publishes the flattened vault shape', async () => {
     const app = TestApp.create({ auth: false, cache })
     const spec = (await (await app.request('/openapi.json')).json()) as OpenApiDocument
-    const operation = spec.paths['/v1/earn/vaults']?.get
+    const operation = spec.paths['/v1/earn/vaults/{vaultId}']?.get
     const parameters = operation?.parameters?.map((parameter) => parameter.name)
     const response = JSON.stringify(resolveSchema(spec, successSchema(operation)))
 
     expect(Object.keys(spec.paths)).toEqual(
       expect.arrayContaining([
         '/v1/earn/addresses/{address}/positions',
-        '/v1/earn/vaults',
-        '/v1/earn/vaults/verified',
         '/v1/earn/vaults/{vaultId}',
         '/v1/earn/vaults/{vaultId}/earnings/{address}',
         '/v1/earn/vaults/{vaultId}/positions/{address}',
@@ -3663,7 +3346,6 @@ describe('OpenAPI', () => {
       ]),
     )
     expect(parameters).toContain('apy.window')
-    expect(parameters).toContain('engine.type')
     expect(parameters).toContain('include')
     expect(parameters).not.toContain('engine.kind')
     expect(parameters).not.toContain('status')
@@ -3689,7 +3371,7 @@ describe('OpenAPI', () => {
   test('documents the rate window parameter', async () => {
     const app = TestApp.create({ auth: false, cache })
     const spec = (await (await app.request('/openapi.json')).json()) as OpenApiDocument
-    const window = spec.paths['/v1/earn/vaults']?.get?.parameters?.find(
+    const window = spec.paths['/v1/earn/vaults/{vaultId}']?.get?.parameters?.find(
       (parameter) => parameter.name === 'apy.window',
     )
 
@@ -3701,7 +3383,7 @@ describe('OpenAPI', () => {
   test('documents the include-gated vault fields', async () => {
     const app = TestApp.create({ auth: false, cache })
     const spec = (await (await app.request('/openapi.json')).json()) as OpenApiDocument
-    const parameters = spec.paths['/v1/earn/vaults']?.get?.parameters ?? []
+    const parameters = spec.paths['/v1/earn/vaults/{vaultId}']?.get?.parameters ?? []
     const include = parameters.find((parameter) => parameter.name === 'include')
 
     expect(include?.description).toContain('`apy,tvl`')