tapimo 0.10.2 → 0.12.0

package/dist/apps/data/routes/earn.js

@@ -2,6 +2,7 @@ import { Hono } from 'hono';
 import { Value as core_Value } from 'ox';
 import { ContractFunctionExecutionError, ContractFunctionRevertedError, ContractFunctionZeroDataError, zeroAddress, } from 'viem';
 import * as z from 'zod/mini';
+import * as Scope from '../../../Scope.js';
 import * as Db from '../../../db/Db.js';
 import * as core_EarnVaults from '../../../db/tables/earnVaults.js';
 import * as Auth from '../../../internal/Auth.js';
@@ -45,6 +46,11 @@ export function discoveryBatchLimit(options) {
     const needed = options.limit + 1 - options.matches;
     return Math.min(options.filtered ? needed * 2 : needed, options.remaining, scanLimit);
 }
+/** Returns whether API-key scopes grant read access to one private Zone. */
+export function hasZoneAccess(options) {
+    const scopes = options.scopes ?? [];
+    return scopes.includes(Scope.wildcard) || scopes.includes(`zone:${options.chainId}:read`);
+}
 /** Zod schemas owned by the public Earn-vault resource. */
 export var schema;
 (function (schema) {
@@ -73,13 +79,13 @@ export var schema;
             .check(z.describe('Yield venue, or null when the engine does not expose one.')),
     }), 'Current vault engine.');
     const include = z
-        .enum(['access', 'apy', 'capabilities', 'token.logoUri', 'tvl', 'zone'])
+        .enum(['access', 'apy', 'capabilities', 'token.logoUri', 'tvl', 'zone', 'zones'])
         .check(z.describe('Optional vault fields to embed via `include`.'));
     const includeQuery = Schema.includeQuery(include, 'Comma-separated vault fields to include, such as `apy,tvl`.');
     // `apy` and `tvl` need indexer and FX access, so surfaces lacking either
     // select from this reduced set instead.
     const baseInclude = z
-        .enum(['access', 'capabilities', 'token.logoUri', 'zone'])
+        .enum(['access', 'capabilities', 'token.logoUri', 'zone', 'zones'])
         .check(z.describe('Optional vault fields to embed via `include`.'));
     const baseIncludeQuery = Schema.includeQuery(baseInclude, 'Comma-separated vault fields to include, such as `access,zone`.');
     const zone = z
@@ -96,6 +102,24 @@ export var schema;
             .check(z.describe('Tokens supported by private redemptions.'), z.meta({ examples: [['0x20c000000000000000000000ff04042ee92fd449']] })),
     })
         .check(z.describe('Private Zone route configured for a verified vault.'));
+    const zoneRoute = z
+        .strictObject({
+        chainId: Schema.ChainId.check(z.describe('Private Zone chain id.'), z.meta({ examples: [1424310001] })),
+        deploymentBlock: z
+            .number()
+            .check(z.int(), z.nonnegative(), z.describe('Parent-chain block that deployed the Earn router.'), z.meta({ examples: [31039238] })),
+        earnRouter: Schema.Address.check(z.describe('Parent-chain router for this Zone and Earn vault.'), z.meta({ examples: ['0x9144086a79dea966d8bf1b52125ebed8919fc45c'] })),
+        inputTokens: z
+            .array(Schema.Address)
+            .check(z.describe('Tokens accepted by private deposits.'), z.meta({ examples: [['0x20c000000000000000000000ff04042ee92fd449']] })),
+        name: z
+            .string()
+            .check(z.describe('Private Zone name.'), z.meta({ examples: ['zone-moderato-internal'] })),
+        outputTokens: z
+            .array(Schema.Address)
+            .check(z.describe('Tokens returned by private redemptions.'), z.meta({ examples: [['0x20c000000000000000000000ff04042ee92fd449']] })),
+    })
+        .check(z.describe('Verified Earn route through one private Zone.'));
     const value = z.strictObject({
         amount: Schema.DecimalString.check(z.describe('Value in base units at `decimals` precision.'), z.meta({ examples: ['125288750000'] })),
         currency: z
@@ -146,6 +170,20 @@ export var schema;
         zone: z
             .optional(z.nullable(zone))
             .check(z.describe('Curated private Zone route, when requested, or null when absent.')),
+        zones: z.optional(z.array(zoneRoute)).check(z.describe('Curated private Zone routes, when requested.'), z.meta({
+            examples: [
+                [
+                    {
+                        chainId: 1424310001,
+                        deploymentBlock: 31039238,
+                        earnRouter: '0x9144086a79dea966d8bf1b52125ebed8919fc45c',
+                        inputTokens: ['0x20c000000000000000000000ff04042ee92fd449'],
+                        name: 'zone-moderato-internal',
+                        outputTokens: ['0x20c000000000000000000000ff04042ee92fd449'],
+                    },
+                ],
+            ],
+        })),
     });
     /** One compatible Earn vault resolved from current chain state. */
     schema.Vault = Schema.describe(vault, 'A compatible earn vault resolved from chain state.');
@@ -426,8 +464,8 @@ export function earn(options = {}) {
     // as current-state rather than slow-changing metadata.
     Cache.response({
         cacheControl: Cache.policies.state,
-        key: (c) => Cache.urlKey(c, schema.getEarnVaults.Query),
-        name: 'tempo-api:earn-vaults:v2',
+        key: (c) => vaultCacheKey(c, schema.getEarnVaults.Query),
+        name: 'tempo-api:earn-vaults:v3',
     }), async (c) => {
         if (Auth.narrowAccess)
             return Auth.paidAccessError(c);
@@ -463,8 +501,8 @@ export function earn(options = {}) {
         tags: ['Earn'],
     }), Cache.response({
         cacheControl: Cache.policies.state,
-        key: (c) => Cache.urlKey(c, schema.getVerifiedEarnVaults.Query),
-        name: 'tempo-api:earn-vaults:v2',
+        key: (c) => vaultCacheKey(c, schema.getVerifiedEarnVaults.Query),
+        name: 'tempo-api:earn-vaults:v3',
     }), async (c) => {
         if (Auth.narrowAccess)
             return Auth.paidAccessError(c);
@@ -765,8 +803,8 @@ export function earn(options = {}) {
         tags: ['Earn'],
     }), Cache.response({
         cacheControl: Cache.policies.state,
-        key: (c) => Cache.urlKey(c, schema.getEarnVault.Query),
-        name: 'tempo-api:earn-vaults:v2',
+        key: (c) => vaultCacheKey(c, schema.getEarnVault.Query),
+        name: 'tempo-api:earn-vaults:v3',
     }), async (c) => {
         if (Auth.narrowAccess)
             return Auth.paidAccessError(c);
@@ -1549,12 +1587,18 @@ export async function listVaults(c, options) {
             Promise.all(page.items.map(async (item) => {
                 const record = registry.get(item.vaultAddress.toLowerCase());
                 try {
-                    const discovery = await resolveVaultDiscovery(c, {
+                    const discovered = await resolveVaultDiscovery(c, {
                         chainId: options.chainId,
                         include: discoveryInclude(options),
                         vaultAddress: item.vaultAddress,
                     });
-                    return { discovery, position: item.position, record };
+                    const { discovery, zoneRoutes } = await resolveVaultRoutes(c, {
+                        capability: options.capability,
+                        discovery: discovered,
+                        include,
+                        record,
+                    });
+                    return { discovery, position: item.position, record, zoneRoutes };
                 }
                 catch (cause) {
                     if (!record && isIncompatible(cause))
@@ -1602,7 +1646,7 @@ export async function listVaults(c, options) {
     for (const [vault, apy] of missingApy ?? [])
         apyByVault.set(vault, apy);
     const apy = include.includes('apy') ? apyByVault : undefined;
-    const data = page.map((match) => resolveVault(c, { ...match, apy, include, rates, snapshot, tokens }));
+    const data = await Promise.all(page.map((match) => resolveVault(c, { ...match, apy, include, rates, snapshot, tokens })));
     const last = matches[options.limit - 1];
     const nextPosition = matches.length > options.limit ? last?.position : hasMore ? position : undefined;
     return {
@@ -1621,6 +1665,7 @@ export async function listVerifiedVaults(c, options) {
     const decoded = options.cursor ? Cursor.decode(options.cursor, ['address']) : undefined;
     const cursor = decoded?.[0]?.toString().toLowerCase();
     const candidates = records.filter((record) => !cursor || record.vaultAddress.toLowerCase() > cursor);
+    const include = vaultInclude(options);
     const matches = [];
     let offset = 0;
     while (offset < candidates.length && matches.length <= options.limit) {
@@ -1632,14 +1677,20 @@ export async function listVerifiedVaults(c, options) {
         });
         const batch = candidates.slice(offset, offset + batchSize);
         offset += batch.length;
-        const discovered = await Promise.all(batch.map(async (record) => ({
-            discovery: await resolveVaultDiscovery(c, {
+        const discovered = await Promise.all(batch.map(async (record) => {
+            const discovered = await resolveVaultDiscovery(c, {
                 chainId: options.chainId,
                 include: discoveryInclude(options),
                 vaultAddress: Schema.Address.parse(record.vaultAddress.toLowerCase()),
-            }),
-            record,
-        })));
+            });
+            const { discovery, zoneRoutes } = await resolveVaultRoutes(c, {
+                capability: options.capability,
+                discovery: discovered,
+                include,
+                record,
+            });
+            return { discovery, record, zoneRoutes };
+        }));
         for (const match of discovered) {
             if (!matchesVaultFilters(match.discovery, options))
                 continue;
@@ -1648,7 +1699,6 @@ export async function listVerifiedVaults(c, options) {
     }
     const page = matches.slice(0, options.limit);
     const discoveries = page.map(({ discovery }) => discovery);
-    const include = vaultInclude(options);
     const [apy, rates, tokens] = await Promise.all([
         resolvePageApy(c, {
             chainId: options.chainId,
@@ -1659,7 +1709,7 @@ export async function listVerifiedVaults(c, options) {
         resolvePageRates(c, { discoveries, include, oracle: options.oracle, snapshot }),
         resolvePageTokens(c, { chainId: options.chainId, discoveries, include, snapshot }),
     ]);
-    const data = page.map((match) => Response.validated(schema.VerifiedVault, resolveVault(c, { ...match, apy, include, rates, snapshot, tokens })));
+    const data = await Promise.all(page.map(async (match) => Response.validated(schema.VerifiedVault, await resolveVault(c, { ...match, apy, include, rates, snapshot, tokens }))));
     const last = matches[options.limit - 1];
     return {
         data,
@@ -1867,13 +1917,19 @@ export async function getVault(c, options) {
         VerifiedTokens.snapshot(c, options.chainId),
     ]);
     try {
-        const discovery = await resolveVaultDiscovery(c, {
+        const discovered = await resolveVaultDiscovery(c, {
             chainId: options.chainId,
             include: discoveryInclude({ capability: [], include: options.include }),
             vaultAddress: options.vaultAddress,
         });
-        const discoveries = [discovery];
         const include = vaultInclude(options);
+        const { discovery, zoneRoutes } = await resolveVaultRoutes(c, {
+            capability: [],
+            discovery: discovered,
+            include,
+            record,
+        });
+        const discoveries = [discovery];
         const [apy, rates, tokens] = await Promise.all([
             resolvePageApy(c, {
                 chainId: options.chainId,
@@ -1885,7 +1941,7 @@ export async function getVault(c, options) {
             resolvePageTokens(c, { chainId: options.chainId, discoveries, include, snapshot }),
         ]);
         return {
-            ...resolveVault(c, {
+            ...(await resolveVault(c, {
                 apy,
                 discovery,
                 include,
@@ -1893,7 +1949,8 @@ export async function getVault(c, options) {
                 record,
                 snapshot,
                 tokens,
-            }),
+                zoneRoutes,
+            })),
             ...(rates ? { meta: { valuation: Valuation.pricing(rates, options.oracle) } } : {}),
         };
     }
@@ -1911,6 +1968,21 @@ function vaultInclude(options) {
         return include;
     return [...include, 'apy'];
 }
+/** Builds an Earn-vault cache key partitioned by Zone-visible API keys. */
+export function vaultCacheKey(c, query) {
+    const key = Cache.urlKey(c, query);
+    const url = new URL(key);
+    const includesRoutes = url.searchParams
+        .getAll('include')
+        .some((include) => include === 'zone' || include === 'zones');
+    if (!includesRoutes)
+        return key;
+    const principal = Auth.getPrincipal(c);
+    if (principal?.type !== 'api_key')
+        return key;
+    url.searchParams.set('principal', `${principal.type}:${principal.id}`);
+    return url.toString();
+}
 function discoveryInclude(options) {
     const includeCapabilities = options.include.includes('capabilities') ||
         options.include.includes('zone') ||
@@ -1937,6 +2009,39 @@ async function resolveVaultDiscovery(c, options) {
         ttl: Ttl.seconds(30),
     });
 }
+async function resolveVaultRoutes(c, options) {
+    const { discovery, record } = options;
+    if (!record || record.zones.length === 0)
+        return { discovery, zoneRoutes: [] };
+    const principal = Auth.getPrincipal(c);
+    const scopes = principal?.type === 'api_key' ? principal.apiKey.scopes : undefined;
+    const includesRoutes = options.include.includes('zone') || options.include.includes('zones');
+    const needsCapabilities = options.include.includes('capabilities') ||
+        options.capability.includes('privateRouting') ||
+        options.capability.includes('routerSwaps');
+    const visibleRoutes = record.zones.filter((route) => hasZoneAccess({ chainId: route.chainId, scopes }));
+    // Capabilities describe the vault; API-key scopes limit only the route metadata.
+    const routes = needsCapabilities ? record.zones : includesRoutes ? visibleRoutes : [];
+    if (routes.length === 0)
+        return { discovery, zoneRoutes: [] };
+    const resolved = await EarnVaults.resolveZoneRoutes({
+        discovery,
+        getClient: c.get('getClient'),
+        routes,
+        zones: [...c.get('zones').values()],
+    });
+    const capabilities = discovery.capabilities;
+    if (needsCapabilities && !capabilities)
+        throw new Error('Earn vault capabilities were not resolved.');
+    return {
+        discovery: capabilities
+            ? { ...discovery, capabilities: EarnVaults.addZoneRouteCapabilities(capabilities) }
+            : discovery,
+        zoneRoutes: includesRoutes
+            ? resolved.filter((route) => hasZoneAccess({ chainId: route.chainId, scopes }))
+            : [],
+    };
+}
 // Measuring a rate costs indexer boundary queries plus historical quotes against
 // an archive node, so an unrequested rate reaches neither.
 function resolvePageApy(c, options) {
@@ -1986,8 +2091,11 @@ async function resolvePageTokens(c, options) {
         snapshot: options.snapshot,
     });
 }
-function resolveVault(c, options) {
+async function resolveVault(c, options) {
     const { discovery, record } = options;
+    const principal = Auth.getPrincipal(c);
+    const scopes = principal?.type === 'api_key' ? principal.apiKey.scopes : undefined;
+    const zones = [...c.get('zones').values()].filter((zone) => hasZoneAccess({ chainId: zone.id, scopes }));
     const valued = options.include.includes('tvl')
         ? Valuation.valuationFor({
             amount: BigInt(discovery.state.totalAssets),
@@ -2011,7 +2119,8 @@ function resolveVault(c, options) {
                 formatted: valued.amount,
             }
             : null,
-        zones: [...c.get('zones').values()],
+        zoneRoutes: options.zoneRoutes,
+        zones,
     });
 }
 /** Serializes resolved onchain and curated fields into the shared vault contract. */
@@ -2051,11 +2160,32 @@ export function serializeVault(options) {
         vaultAddress,
         verified: record !== undefined,
         ...(options.include.includes('zone')
-            ? { zone: record ? resolveZone({ discovery, record, zones: options.zones }) : null }
+            ? {
+                zone: record
+                    ? resolveZone({
+                        discovery,
+                        record,
+                        zoneRoutes: options.zoneRoutes,
+                        zones: options.zones,
+                    })
+                    : null,
+            }
             : {}),
+        ...(options.include.includes('zones') ? { zones: record ? options.zoneRoutes : [] } : {}),
     });
 }
 function resolveZone(options) {
+    if (options.record.zones.length > 0) {
+        if (options.zoneRoutes.length !== 1)
+            return null;
+        const route = options.zoneRoutes[0];
+        return {
+            chainId: route.chainId,
+            inputTokens: [...route.inputTokens],
+            name: route.name,
+            outputTokens: [...route.outputTokens],
+        };
+    }
     if (!options.discovery.capabilities?.privateRouting)
         return null;
     const hasInputs = options.record.privateInputTokens.length > 0;
@@ -2065,6 +2195,8 @@ function resolveZone(options) {
     if (hasInputs !== hasOutputs)
         throw new Error('Private input and output tokens must both be configured.');
     const configured = options.zones.filter((zone) => zone.sourceId === options.record.chainId);
+    if (configured.length === 0)
+        return null;
     if (configured.length !== 1)
         throw new Error(`Expected one Earn Zone for chain ${options.record.chainId}.`);
     const zone = configured[0];