tapimo 0.10.2 → 0.12.0

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

@@ -297,7 +297,7 @@ export function addresses(options: addresses.Options = {}) {
         } catch (cause) {
           if (cause instanceof Valuation.UnsupportedDenominationError)
             return Response.error(c, { code: 'query_invalid', message: cause.message, status: 400 })
-          return Response.upstream(c, cause)
+          return Response.upstream(c, cause, { page: query.page })
         }
       },
     )

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

@@ -420,7 +420,7 @@ export function blocks() {
           })
           return c.json(Response.validated(schema.getBlocks.Response, page), 200)
         } catch (cause) {
-          return Response.upstream(c, cause)
+          return Response.upstream(c, cause, { page: query.page })
         }
       },
     )

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

@@ -23,29 +23,46 @@ type EnrichedVault = Pick<
   'apy' | 'instantLiquidity' | 'sharePrice' | 'state' | 'tvl'
 >
 
+type OpenApiSchema = { $ref?: string }
+
+type OpenApiOperation = {
+  description?: string
+  parameters?: readonly {
+    description?: string
+    name?: string
+    schema?: { enum?: readonly unknown[]; examples?: readonly unknown[]; pattern?: string }
+  }[]
+  responses?: Record<string, { content?: { 'application/json'?: { schema?: OpenApiSchema } } }>
+}
+
 type OpenApiDocument = {
+  components?: { schemas?: Record<string, unknown> }
   paths: Record<
     string,
     {
-      get?: {
-        description?: string
-        parameters?: readonly {
-          description?: string
-          name?: string
-          schema?: { enum?: readonly unknown[]; examples?: readonly unknown[]; pattern?: string }
-        }[]
-        responses?: Record<string, unknown>
-      }
+      get?: OpenApiOperation
     }
   >
 }
 
+function errorSchemas(document: OpenApiDocument, operation: OpenApiOperation | undefined) {
+  return JSON.stringify(
+    Object.entries(operation?.responses ?? {})
+      .filter(([status]) => !status.startsWith('2'))
+      .map(([, response]) => {
+        const schema = response.content?.['application/json']?.schema
+        const name = schema?.$ref?.split('/').at(-1)
+        return name ? document.components?.schemas?.[name] : schema
+      }),
+  )
+}
+
 describe('schema.getEarnVaults.Query', () => {
   test('parses collection filters', () => {
     const query = Earn.schema.getEarnVaults.Query.parse({
       capability: 'deposit,exactWithdraw',
       'engine.type': 'erc4626',
-      include: 'access,apy,capabilities,zone,token.logoUri,tvl',
+      include: 'access,apy,capabilities,zone,zones,token.logoUri,tvl',
       limit: '10',
     })
 
@@ -56,6 +73,7 @@ describe('schema.getEarnVaults.Query', () => {
       'apy',
       'capabilities',
       'zone',
+      'zones',
       'token.logoUri',
       'tvl',
     ])
@@ -365,6 +383,143 @@ describe('GET /v1/earn/vaults/verified', () => {
     })
   })
 
+  test.runIf(Runtime.get().mode === 'testnet')(
+    'folds scoped Zone routes into vault capabilities',
+    async () => {
+      const db = TestApp.database()
+      await core_EarnVaults.upsert(db, TestEarn.zoneVerifiedVault)
+      const otherZoneId = TestEarn.zone.id + 1
+      const scopedKey = {
+        ...TestApp.key,
+        id: 'key_earn_zones',
+        scopes: ['data:read', `zone:${otherZoneId}:read`, `zone:${TestEarn.zone.id}:read`],
+        token: 'secret_earn_zones',
+      } satisfies TestApp.kvStore.Key
+      const unrelatedKey = {
+        ...TestApp.key,
+        id: 'key_earn_other_zone',
+        scopes: ['data:read', `zone:${otherZoneId}:read`],
+        token: 'secret_earn_other_zone',
+      } satisfies TestApp.kvStore.Key
+      const writeOnlyKey = {
+        ...TestApp.key,
+        id: 'key_earn_write_zone',
+        scopes: ['data:read', `zone:${TestEarn.zone.id}:write`],
+        token: 'secret_earn_write_zone',
+      } satisfies TestApp.kvStore.Key
+      const wildcardKey = {
+        ...TestApp.key,
+        id: 'key_earn_all_zones',
+        scopes: ['*'],
+        token: 'secret_earn_all_zones',
+      } satisfies TestApp.kvStore.Key
+      const app = TestApp.create({
+        auth: { keys: [scopedKey, unrelatedKey, wildcardKey, writeOnlyKey] },
+        cache,
+        db,
+        zones: [TestEarn.zone],
+      })
+      const base = `/v1/earn/vaults/verified?chainId=${TestEarn.chain.id}&limit=5`
+      const included = `${base}&include=capabilities,zone,zones`
+      const filtered = `${included}&capability=privateRouting`
+      // Fill the query-credential cache entry before checking callers without its Zone scope.
+      const scopedResponse = await app.request(`${filtered}&key=${scopedKey.token}`)
+      const [
+        defaultResponse,
+        unrelatedResponse,
+        publicResponse,
+        wildcardResponse,
+        writeOnlyResponse,
+      ] = await Promise.all([
+        app.request(base, { headers: { 'tempo-api-key': scopedKey.token } }),
+        app.request(included, { headers: { 'tempo-api-key': unrelatedKey.token } }),
+        app.request(filtered),
+        app.request(filtered, { headers: { 'tempo-api-key': wildcardKey.token } }),
+        app.request(filtered, { headers: { 'tempo-api-key': writeOnlyKey.token } }),
+      ])
+
+      expect([
+        defaultResponse.status,
+        scopedResponse.status,
+        unrelatedResponse.status,
+        publicResponse.status,
+        wildcardResponse.status,
+        writeOnlyResponse.status,
+      ]).toStrictEqual([200, 200, 200, 200, 200, 200])
+      const [defaultBody, scopedBody, unrelatedBody, publicBody, wildcardBody, writeOnlyBody] =
+        await Promise.all([
+          TestApp.json(defaultResponse, Earn.schema.getVerifiedEarnVaults.Response),
+          TestApp.json(scopedResponse, Earn.schema.getVerifiedEarnVaults.Response),
+          TestApp.json(unrelatedResponse, Earn.schema.getVerifiedEarnVaults.Response),
+          TestApp.json(publicResponse, Earn.schema.getVerifiedEarnVaults.Response),
+          TestApp.json(wildcardResponse, Earn.schema.getVerifiedEarnVaults.Response),
+          TestApp.json(writeOnlyResponse, Earn.schema.getVerifiedEarnVaults.Response),
+        ])
+      expect(defaultBody.data[0]).not.toHaveProperty('zone')
+      expect(defaultBody.data[0]).not.toHaveProperty('zones')
+      expect(unrelatedBody.data[0]).toMatchObject({
+        capabilities: { privateRouting: true, routerSwaps: true },
+        zone: null,
+        zones: [],
+      })
+      expect(publicBody.data[0]).toMatchObject({
+        capabilities: { privateRouting: true, routerSwaps: true },
+        zone: null,
+        zones: [],
+      })
+      expect(writeOnlyBody.data[0]).toMatchObject({ zone: null, zones: [] })
+      const vault = scopedBody.data[0]
+      expect(vault?.capabilities).toMatchObject({ privateRouting: true, routerSwaps: true })
+      expect(vault?.zones).toHaveLength(1)
+      expect(vault?.zones?.[0]).toMatchObject(TestEarn.zoneRoute)
+      expect(vault?.zone).toStrictEqual(
+        vault?.zones?.[0]
+          ? {
+              chainId: vault.zones[0].chainId,
+              inputTokens: vault.zones[0].inputTokens,
+              name: vault.zones[0].name,
+              outputTokens: vault.zones[0].outputTokens,
+            }
+          : null,
+      )
+      expect(wildcardBody.data[0]).toStrictEqual(vault)
+    },
+    90_000,
+  )
+
+  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 () => {
@@ -467,14 +622,11 @@ describe('GET /v1/earn/vaults/verified', () => {
         db,
         zones: [TestEarn.zone],
       })
-      const request = { headers: { 'cache-control': 'no-store' } }
       const detail = await app.request(
         `/v1/earn/vaults/${TestEarn.vaultAddress}?chainId=${TestEarn.chain.id}&include=access,capabilities,zone`,
-        request,
       )
       const verified = await app.request(
         `/v1/earn/vaults/verified?chainId=${TestEarn.chain.id}&include=access,capabilities,zone&limit=5`,
-        request,
       )
 
       expect([detail.status, verified.status]).toStrictEqual([200, 200])
@@ -552,6 +704,7 @@ describe('GET /v1/earn/vaults/verified', () => {
           privateInputTokens: [],
           privateOutputTokens: [],
           vaultAddress,
+          zones: [],
         })
       const app = TestApp.create({ auth: false, cache, db, zones: [TestEarn.zone] })
       const cursor = Cursor.encode([TestEarn.indexedDeployment.vaultAddress])
@@ -1558,6 +1711,9 @@ describe('OpenAPI', () => {
     expect(response).toContain('"type"')
     expect(response).toContain('"vaultAddress"')
     expect(response).toContain('"zone"')
+    expect(response).toContain('"zones"')
+    expect(response).toContain('"deploymentBlock"')
+    expect(response).toContain('"earnRouter"')
     expect(response).toContain('"apy"')
     expect(response).toContain('"instantLiquidity"')
     expect(response).toContain('"sharePrice"')
@@ -1590,6 +1746,7 @@ describe('OpenAPI', () => {
     expect(include?.description).toContain('`apy,tvl`')
     expect(JSON.stringify(include?.schema)).toContain('"apy"')
     expect(JSON.stringify(include?.schema)).toContain('"tvl"')
+    expect(JSON.stringify(include?.schema)).toContain('"zones"')
   })
 
   test('documents vault-position inputs and responses', async () => {
@@ -1597,14 +1754,15 @@ describe('OpenAPI', () => {
     const spec = (await (await app.request('/openapi.json')).json()) as OpenApiDocument
     const operation = spec.paths['/v1/earn/vaults/{vaultId}/positions/{address}']?.get
     const address = operation?.parameters?.find((parameter) => parameter.name === 'address')
+    const errors = errorSchemas(spec, operation)
     const response = JSON.stringify(operation?.responses)
     const vaultId = operation?.parameters?.find((parameter) => parameter.name === 'vaultId')
 
-    expect(response).toContain('"chain_id_invalid"')
-    expect(response).toContain('"chain_id_unsupported"')
-    expect(response).toContain('"position_invalid"')
-    expect(response).toContain('"query_invalid"')
-    expect(response).toContain('"earn_vault_not_found"')
+    expect(errors).toContain('"chain_id_invalid"')
+    expect(errors).toContain('"chain_id_unsupported"')
+    expect(errors).toContain('"position_invalid"')
+    expect(errors).toContain('"query_invalid"')
+    expect(errors).toContain('"earn_vault_not_found"')
     expect(response).toContain('Stable resource ID for this vault position')
     expect(response).toContain('0x20c000000000000000000000b9537d11c60e8b50')
     expect(response).toContain('0x20c000000000000000000000300e14ab91a10769')
@@ -1621,6 +1779,7 @@ describe('OpenAPI', () => {
       (parameter) => parameter.name === 'valuation.currency',
     )
     const verified = operation?.parameters?.find((parameter) => parameter.name === 'verified')
+    const errors = errorSchemas(spec, operation)
     const response = JSON.stringify(operation?.responses)
 
     expect(operation?.description).toContain('currently holds shares')
@@ -1628,10 +1787,10 @@ describe('OpenAPI', () => {
     expect(denomination?.description).toContain('nominal value')
     expect(verified?.description).toContain('registry-curated')
     expect(verified?.schema?.examples).toStrictEqual([true])
-    expect(response).toContain('"chain_id_invalid"')
-    expect(response).toContain('"chain_id_unsupported"')
-    expect(response).toContain('"positions_invalid"')
-    expect(response).toContain('"query_invalid"')
+    expect(errors).toContain('"chain_id_invalid"')
+    expect(errors).toContain('"chain_id_unsupported"')
+    expect(errors).toContain('"positions_invalid"')
+    expect(errors).toContain('"query_invalid"')
     expect(response).toContain('Stable resource ID for this position')
     expect(response).toContain('Current asset value of the held shares')
     expect(response).toContain('"assetAmount"')
@@ -1647,6 +1806,7 @@ describe('OpenAPI', () => {
     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/{vaultId}/earnings/{address}']?.get
+    const errors = errorSchemas(spec, operation)
     const period = operation?.parameters?.find((parameter) => parameter.name === 'period')
     const response = JSON.stringify(operation?.responses)
 
@@ -1654,7 +1814,7 @@ describe('OpenAPI', () => {
     expect(period?.description).toContain('trailing 30 days')
     expect(period?.schema?.enum).toStrictEqual(['30d', 'active', 'lifetime'])
     expect(period?.schema?.examples).toStrictEqual(['lifetime'])
-    expect(response).toContain('"earn_vault_not_found"')
+    expect(errors).toContain('"earn_vault_not_found"')
     expect(response).toContain('Stable resource ID for these vault earnings')
     expect(response).toContain('Current share value plus completed redemptions')
     expect(response).toContain('weighted-average asset cost basis')