ad providers endpoint

Author: dglowinski

src/api/routes/swap/swapModel.ts

@@ -8,6 +8,7 @@ extendZodWithOpenApi(z)
 export type Meta = z.infer<typeof metaSchema>
 export type SwapResponseSingle = z.infer<typeof swapResponseSchemaSingle>
 export type SwapResponse = z.infer<typeof swapResponseSchema>
+export type ProvidersResponse = z.infer<typeof providersResponseSchema>
 
 const addressSchema = z
   .string()
@@ -343,4 +344,26 @@ const swapResponseSchemaSingle = z.object({
 
 const swapResponseSchema = z.array(swapResponseSchemaSingle)
 
-export { getSwapSchema, swapResponseSchemaSingle, swapResponseSchema }
+const getProvidersSchema = z.object({
+  query: z.object({
+    chainId: z
+      .string()
+      .transform(Number)
+      .pipe(z.number().int().positive())
+      .openapi({ example: "1", param: { description: "Chain id" } }),
+  }),
+})
+
+const providersResponseSchema = z
+  .array(z.string())
+  .openapi({
+    description: "Array of providers for use with `swapWithProvider` endpoint",
+  })
+
+export {
+  getSwapSchema,
+  swapResponseSchemaSingle,
+  swapResponseSchema,
+  getProvidersSchema,
+  providersResponseSchema,
+}

src/api/routes/swap/swapRouter.ts

@@ -9,7 +9,7 @@ import {
   validateRequest,
 } from "@/common/utils/httpHandlers"
 import { log, logProd, logRouteTime } from "@/common/utils/logs"
-import { findSwaps } from "@/swapService/runner"
+import { findSwaps, reflectProviders } from "@/swapService/runner"
 import type { SwapParams } from "@/swapService/types"
 import {
   ApiError,
@@ -21,9 +21,12 @@ import { StatusCodes } from "http-status-codes"
 import { InvalidAddressError } from "viem"
 import { z } from "zod"
 import {
+  type ProvidersResponse,
   type SwapResponse,
   type SwapResponseSingle,
+  getProvidersSchema,
   getSwapSchema,
+  providersResponseSchema,
   swapResponseSchema,
   swapResponseSchemaSingle,
 } from "./swapModel"
@@ -49,6 +52,35 @@ swapRegistry.registerPath({
   responses: createApiResponse(swapResponseSchema, "Success"),
 })
 
+swapRegistry.register("Providers", providersResponseSchema)
+swapRegistry.registerPath({
+  method: "get",
+  path: "/providers",
+  tags: ["Get providers available for the queried chain"],
+  request: { query: getProvidersSchema.shape.query },
+  responses: createApiResponse(providersResponseSchema, "Success"),
+})
+
+swapRouter.get(
+  "/providers",
+  validateRequest(getProvidersSchema),
+  async (req: Request, res: Response) => {
+    try {
+      const {
+        query: { chainId },
+      } = getProvidersSchema.parse(req)
+      const providers = await reflectProviders(chainId)
+
+      return handleServiceResponse(
+        ServiceResponse.success<ProvidersResponse>(providers),
+        res,
+      )
+    } catch (error) {
+      return handleServiceResponse(createFailureResponse(req, error), res)
+    }
+  },
+)
+
 swapRouter.get(
   "/swap",
   validateRequest(getSwapSchema),

src/swapService/runner.ts

@@ -12,12 +12,12 @@ import { strategies } from "./strategies/index"
 import type { StrategyResult, SwapParams } from "./types"
 import { ApiError, addInOutDeposits } from "./utils"
 
-function loadPipeline(swapParams: SwapParams) {
+function loadPipeline(chainId: number, routingOverride?: ChainRoutingConfig) {
   let routing: ChainRoutingConfig
-  if (swapParams.routingOverride) {
-    routing = swapParams.routingOverride
+  if (routingOverride) {
+    routing = routingOverride
   } else {
-    routing = getRoutingConfig(swapParams.chainId)
+    routing = getRoutingConfig(chainId)
     if (!routing)
       throw new ApiError(
         StatusCodes.NOT_FOUND,
@@ -36,7 +36,7 @@ function loadPipeline(swapParams: SwapParams) {
 export async function runPipeline(
   swapParams: SwapParams,
 ): Promise<SwapApiResponse[]> {
-  const pipeline = loadPipeline(swapParams)
+  const pipeline = loadPipeline(swapParams.chainId, swapParams.routingOverride)
 
   const allResults: StrategyResult[] = []
   for (const strategy of pipeline) {
@@ -104,3 +104,15 @@ export async function findSwaps(swapParams: SwapParams) {
 
   return quotes
 }
+
+export async function reflectProviders(chainId: number) {
+  const pipeline = loadPipeline(chainId)
+
+  return [
+    ...new Set(
+      (
+        await Promise.all(pipeline.map((strategy) => strategy.providers()))
+      ).flat(),
+    ),
+  ]
+}

src/swapService/strategies/strategyBalmySDK.ts

@@ -95,6 +95,8 @@ export class StrategyBalmySDK {
       config.sourcesFilter.includeSources.push(
         ...allPendleAggregators.map((aggregator) => `pendle-${aggregator}`),
       )
+      config.sourcesFilter.includeSources =
+        config.sourcesFilter.includeSources.filter((s) => s !== "pendle")
     }
 
     this.config = { ...defaultConfig, ...(config || {}) }
@@ -127,9 +129,9 @@ export class StrategyBalmySDK {
             "li-fi": {
               apiKey: String(process.env.LIFI_API_KEY),
             },
-            pendle: {
-              apiKey: String(process.env.PENDLE_API_KEY),
-            },
+            // pendle: {
+            //   apiKey: String(process.env.PENDLE_API_KEY),
+            // },
             "open-ocean": {
               apiKey: String(process.env.OPENOCEAN_API_KEY),
             },
@@ -197,6 +199,10 @@ export class StrategyBalmySDK {
     )
   }
 
+  async providers(): Promise<string[]> {
+    return this.config.sourcesFilter?.includeSources || []
+  }
+
   async findSwap(swapParams: SwapParams): Promise<StrategyResult> {
     const result: StrategyResult = {
       strategy: StrategyBalmySDK.name(),

src/swapService/strategies/strategyCombinedUniswap.ts

@@ -53,6 +53,10 @@ export class StrategyCombinedUniswap {
     )
   }
 
+  async providers(): Promise<string[]> {
+    return [] // relies on providers of underlying strategies
+  }
+
   async findSwap(swapParams: SwapParams): Promise<StrategyResult> {
     const result: StrategyResult = {
       strategy: StrategyCombinedUniswap.name(),

src/swapService/strategies/strategyConnect2.ts

@@ -47,6 +47,10 @@ export class StrategyConnect2 {
     )
   }
 
+  async providers(): Promise<string[]> {
+    return [] // TODO
+  }
+
   async findSwap(swapParams: SwapParams): Promise<StrategyResult> {
     const result: StrategyResult = {
       strategy: StrategyConnect2.name(),

src/swapService/strategies/strategyCurveLPNG.ts

@@ -75,6 +75,10 @@ export class StrategyCurveLPNG {
     )
   }
 
+  async providers(): Promise<string[]> {
+    return ["custom"]
+  }
+
   async findSwap(swapParams: SwapParams): Promise<StrategyResult> {
     const result: StrategyResult = {
       strategy: StrategyCurveLPNG.name(),

src/swapService/strategies/strategyERC4626Wrapper.ts

@@ -273,6 +273,10 @@ export class StrategyERC4626Wrapper {
     )
   }
 
+  async providers(): Promise<string[]> {
+    return ["custom"]
+  }
+
   async findSwap(swapParams: SwapParams): Promise<StrategyResult> {
     const result: StrategyResult = {
       strategy: StrategyERC4626Wrapper.name(),

src/swapService/strategies/strategyElixir.ts

@@ -78,6 +78,10 @@ export class StrategyElixir {
     )
   }
 
+  async providers(): Promise<string[]> {
+    return ["custom"]
+  }
+
   async findSwap(swapParams: SwapParams): Promise<StrategyResult> {
     const result: StrategyResult = {
       strategy: StrategyElixir.name(),

src/swapService/strategies/strategyIdleCDOTranche.ts

@@ -78,6 +78,10 @@ export class StrategyIdleCDOTranche {
     )
   }
 
+  async providers(): Promise<string[]> {
+    return ["custom"]
+  }
+
   async findSwap(swapParams: SwapParams): Promise<StrategyResult> {
     const result: StrategyResult = {
       strategy: StrategyIdleCDOTranche.name(),