tapimo 0.14.0 → 0.15.0

package/src/apps/{funding → routes}/routes/quotes.ts

@@ -1,35 +1,34 @@
-import { Hono } from 'hono'
+import { Hono, type Context } from 'hono'
 import * as z from 'zod/mini'
 
 import type * as App from '../../../App.js'
 import * as Auth from '../../../internal/Auth.js'
-import * as FundingCatalog from '../../../internal/funding/Catalog.js'
-import * as FundingProvider from '../../../internal/funding/Provider.js'
+import * as RoutesCatalog from '../../../internal/routes/Catalog.js'
+import * as RoutesProvider from '../../../internal/routes/Provider.js'
 import * as OpenApi from '../../../internal/OpenApi.js'
 import * as Response from '../../../internal/Response.js'
 import * as Schema from '../../../internal/Schema.js'
 import * as Value from '../../../internal/Value.js'
-import * as ProviderAttempts from '../ProviderAttempts.js'
 
-/** Zod schemas owned by funding quote resources. */
+/** Zod schemas owned by route quote resources. */
 export namespace schema {
-  /** Successful live funding quote. */
-  export const FundingQuote = FundingProvider.schema.FundingQuote
+  /** Successful live route quote. */
+  export const RoutesQuote = RoutesProvider.schema.RoutesQuote
 
-  /** Schemas for the quoteFunding operation. */
-  export namespace quoteFunding {
-    /** Query parameters for live funding quotes. */
-    export const Query = FundingProvider.schema.QuoteRequest
+  /** Schemas for the quoteRoutes operation. */
+  export namespace quoteRoutes {
+    /** Query parameters for live route quotes. */
+    export const Query = RoutesProvider.schema.QuoteRequest
 
-    /** Non-paginated list of successful funding quotes. */
+    /** Non-paginated list of successful route quotes. */
     export const Response = OpenApi.component(
       Schema.describe(
         z.object({
-          data: z.array(FundingQuote).check(z.describe('Successful live funding quotes.')),
+          data: z.array(RoutesQuote).check(z.describe('Successful live route quotes.')),
         }),
-        'A non-paginated list of successful live funding quotes.',
+        'A non-paginated list of successful live route quotes.',
       ),
-      'FundingQuoteList',
+      'RoutesQuoteList',
     )
   }
 }
@@ -52,7 +51,7 @@ const baseUsdcExample = {
   verified: true,
 } as const
 
-const fundingQuoteResponseExample = {
+const routesQuoteResponseExample = {
   data: [
     {
       destinationAmount: Value.tokenAmount({
@@ -85,8 +84,6 @@ const fundingQuoteResponseExample = {
       provider: { id: 'relay', name: 'Relay' },
       quality: {
         estimatedSeconds: 1,
-        liquiditySource: 'providerQuote',
-        sourceDetail: 'relay:quote-v2',
         tier: 'liquid',
       },
       quote: {
@@ -101,20 +98,20 @@ const fundingQuoteResponseExample = {
       sourceToken: baseUsdcExample,
     },
   ],
-} satisfies z.output<typeof schema.quoteFunding.Response>
+} satisfies z.output<typeof schema.quoteRoutes.Response>
 
-/** Mounts live funding quote routes. */
+/** Mounts live route quote routes. */
 export function quotes() {
   return new Hono<App.Environment>().get(
-    '/v1/funding/quotes',
+    '/v1/routes/quotes',
     Auth.policy({ apiKey: { scopes: ['data:read'] }, mpp: true, public: true }),
-    OpenApi.validate('query', schema.quoteFunding.Query, {
+    OpenApi.validate('query', schema.quoteRoutes.Query, {
       code: 'query_invalid',
       message: 'Invalid query parameters',
     }),
     OpenApi.describeRoute({
-      description: 'Returns live quotes for transferring stablecoins to Tempo.',
-      operationId: 'quoteFunding',
+      description: 'Returns live quotes for transferring stablecoins between supported chains.',
+      operationId: 'quoteRoutes',
       responses: OpenApi.responses({
         errors: {
           400: { codes: ['query_invalid'] },
@@ -125,9 +122,9 @@ export function quotes() {
           },
         },
         success: {
-          description: 'Live funding quotes. An empty list means no provider returned a quote.',
-          example: fundingQuoteResponseExample,
-          schema: schema.quoteFunding.Response,
+          description: 'Live route quotes. An empty list means no provider returned a quote.',
+          example: routesQuoteResponseExample,
+          schema: schema.quoteRoutes.Response,
         },
       }),
       summary: 'Get quotes',
@@ -142,27 +139,37 @@ export function quotes() {
         })
 
       const query = c.req.valid('query')
-      const attempts: FundingProvider.ProviderAttempt[] = []
-      const catalog = await FundingCatalog.snapshot(c)
-      const providers = c.get('providers').filter(FundingProvider.is)
+      const attempts: RoutesProvider.ProviderAttempt[] = []
+      const providers = c.get('providers').filter(RoutesProvider.is)
       try {
         c.header('Cache-Control', 'no-store')
-        const data = await FundingProvider.getQuotes({
+        const catalog = await RoutesCatalog.snapshot(c).catch((cause) => {
+          c.set('routesQuoteResult', {
+            candidateCount: 0,
+            outcome: 'failed',
+            quotes: [],
+          })
+          throw cause
+        })
+        const data = await RoutesProvider.getQuotes({
           cache: { bypass: cacheBypass(c.req.raw) },
           catalog,
+          destinationChain: query.destinationChain ?? 'tempo',
           destinationToken: query.destinationToken,
           onAttempt: (attempt) => attempts.push(attempt),
+          onResult: (result) => c.set('routesQuoteResult', result),
           provider: query.provider,
           providers,
+          quotaKey: providerQuotaKey(c),
           sourceAmount: query.sourceAmount,
           sourceAmountUnits: query.sourceAmountUnits,
           sourceChain: query.sourceChain,
           sourceToken: query.sourceToken,
         })
         if (attempts.length > 0)
-          c.set('fundingProviderAttempts', attempts.map(ProviderAttempts.format))
+          c.set('routesProviderAttempts', attempts.map(RoutesProvider.formatAttempt))
         return c.json(
-          Response.validated(schema.quoteFunding.Response, {
+          Response.validated(schema.quoteRoutes.Response, {
             data,
           }),
           200,
@@ -170,9 +177,9 @@ export function quotes() {
       } catch (cause) {
         const message = requestErrorMessage(cause)
         if (message) return Response.error(c, { code: 'query_invalid', message, status: 400 })
-        if (cause instanceof FundingProvider.ProviderQuoteError) {
-          if (cause.fundingProviderAttempts.length > 0)
-            c.set('fundingProviderAttempts', cause.fundingProviderAttempts)
+        if (cause instanceof RoutesProvider.ProviderQuoteError) {
+          if (cause.routesProviderAttempts.length > 0)
+            c.set('routesProviderAttempts', cause.routesProviderAttempts)
           if (cause.providerFailure) c.set('providerFailure', cause.providerFailure)
           if (cause.providerFailures) c.set('providerFailures', cause.providerFailures)
           return Response.error(c, {
@@ -187,13 +194,23 @@ export function quotes() {
   )
 }
 
+function providerQuotaKey(c: Context<App.Environment>) {
+  const principal = Auth.getPrincipal(c)
+  if (!principal) return 'public:anonymous'
+  if (principal.type === 'api_key')
+    return `organization:${principal.environment}:${principal.orgId}`
+  return `${principal.type}:${principal.id}`
+}
+
 // Maps caller-input errors to a specific 400 message; anything else rethrows.
 function requestErrorMessage(cause: unknown) {
-  if (cause instanceof FundingProvider.InvalidAmountError) return 'Invalid `sourceAmount`.'
-  if (cause instanceof FundingProvider.UnsupportedDestinationTokenError)
+  if (cause instanceof RoutesProvider.InvalidAmountError) return 'Invalid `sourceAmount`.'
+  if (cause instanceof RoutesProvider.UnsupportedDestinationChainError)
+    return 'Unsupported `destinationChain`.'
+  if (cause instanceof RoutesProvider.UnsupportedDestinationTokenError)
     return 'Unsupported `destinationToken`.'
-  if (cause instanceof FundingProvider.UnsupportedProviderError) return 'Unsupported `provider`.'
-  if (cause instanceof FundingProvider.UnsupportedSourceChainError)
+  if (cause instanceof RoutesProvider.UnsupportedProviderError) return 'Unsupported `provider`.'
+  if (cause instanceof RoutesProvider.UnsupportedSourceChainError)
     return 'Unsupported `sourceChain`.'
   return undefined
 }