add /swaps

Author: dglowinski

src/api/routes/swap/swapModel.ts

@@ -6,6 +6,7 @@ import { z } from "zod"
 extendZodWithOpenApi(z)
 
 export type Meta = z.infer<typeof metaSchema>
+export type SwapResponseSingle = z.infer<typeof swapResponseSchemaSingle>
 export type SwapResponse = z.infer<typeof swapResponseSchema>
 
 const addressSchema = z
@@ -265,7 +266,7 @@ const getSwapSchema = z.object({
   }),
 })
 
-const swapResponseSchema = z.object({
+const swapResponseSchemaSingle = z.object({
   amountIn: z.string().openapi({
     description:
       "In exact output - the trade quote. In exact input - the exact sold amount",
@@ -320,4 +321,6 @@ const swapResponseSchema = z.object({
     .openapi({ description: "Swap route details" }),
 })
 
-export { getSwapSchema, swapResponseSchema }
+const swapResponseSchema = z.array(swapResponseSchemaSingle)
+
+export { getSwapSchema, swapResponseSchemaSingle, swapResponseSchema }

src/api/routes/swap/swapRouter.ts

@@ -8,88 +8,90 @@ import {
   handleServiceResponse,
   validateRequest,
 } from "@/common/utils/httpHandlers"
-import { runPipeline } from "@/swapService/runner"
+import { findSwaps } from "@/swapService/runner"
 import type { SwapParams } from "@/swapService/types"
-import {
-  ApiError,
-  addInOutDeposits,
-  findToken,
-  getSwapper,
-} from "@/swapService/utils"
+import { ApiError, findToken, getSwapper } from "@/swapService/utils"
 import { StatusCodes } from "http-status-codes"
-import { InvalidAddressError, isHex } from "viem"
+import { InvalidAddressError } from "viem"
 import { z } from "zod"
 import {
   type SwapResponse,
+  type SwapResponseSingle,
   getSwapSchema,
   swapResponseSchema,
+  swapResponseSchemaSingle,
 } from "./swapModel"
 
 export const swapRegistry = new OpenAPIRegistry()
 export const swapRouter: Router = express.Router()
 
-swapRegistry.register("SwapQuote", swapResponseSchema)
+swapRegistry.register("SwapQuote", swapResponseSchemaSingle)
 swapRegistry.registerPath({
   method: "get",
   path: "/swap",
-  tags: ["Get swap quote"],
+  tags: ["Get the best swap quote"],
+  request: { query: getSwapSchema.shape.query },
+  responses: createApiResponse(swapResponseSchemaSingle, "Success"),
+})
+
+swapRegistry.register("SwapQuotes", swapResponseSchema)
+swapRegistry.registerPath({
+  method: "get",
+  path: "/swaps",
+  tags: ["Get swap quotes ordered from best to worst"],
   request: { query: getSwapSchema.shape.query },
   responses: createApiResponse(swapResponseSchema, "Success"),
 })
 
 swapRouter.get(
-  "/",
+  "/swap",
   validateRequest(getSwapSchema),
   async (req: Request, res: Response) => {
-    const serviceResponse = await findSwap(req)
-    console.log("===== END =====")
-    return handleServiceResponse(serviceResponse, res)
+    try {
+      const swaps = await findSwaps(parseRequest(req))
+      return handleServiceResponse(
+        ServiceResponse.success<SwapResponseSingle>(swaps[0]),
+        res,
+      )
+    } catch (error) {
+      return handleServiceResponse(createFailureResponse(req, error), res)
+    } finally {
+      console.log("===== END =====")
+    }
   },
 )
 
-async function findSwap(
-  req: Request,
-): Promise<ServiceResponse<SwapResponse | null>> {
-  try {
-    const swapParams = parseRequest(req)
-
-    let data = await runPipeline(swapParams)
-
-    // GLOBAL CHECKS
-    data = addInOutDeposits(swapParams, data)
-
-    // make sure verify item includes at least a function selector
-    if (
-      !isHex(data.verify.verifierData) ||
-      data.verify.verifierData.length < 10
-    )
-      throw new ApiError(
-        StatusCodes.INTERNAL_SERVER_ERROR,
-        "Verifier transaction is empty",
-      )
-
-    return ServiceResponse.success<SwapResponse>(data)
-  } catch (error) {
-    console.log(
-      "error: ",
-      error.statusCode,
-      error.message,
-      error.errorMessage,
-      JSON.stringify(error.data),
-      req.url,
-    )
-    if (error instanceof ApiError) {
-      return ServiceResponse.failure(
-        error.message,
-        error.statusCode,
-        error.data,
+swapRouter.get(
+  "/swaps",
+  validateRequest(getSwapSchema),
+  async (req: Request, res: Response) => {
+    try {
+      const swaps = await findSwaps(parseRequest(req))
+      return handleServiceResponse(
+        ServiceResponse.success<SwapResponse>(swaps),
+        res,
       )
+    } catch (error) {
+      return handleServiceResponse(createFailureResponse(req, error), res)
+    } finally {
+      console.log("===== END =====")
     }
-    return ServiceResponse.failure(
-      `${error}`,
-      StatusCodes.INTERNAL_SERVER_ERROR,
-    )
+  },
+)
+
+function createFailureResponse(req: Request, error: any) {
+  console.log(
+    "error: ",
+    error.statusCode,
+    error.message,
+    error.errorMessage,
+    JSON.stringify(error.data),
+    req.url,
+  )
+  if (error instanceof ApiError) {
+    return ServiceResponse.failure(error.message, error.statusCode, error.data)
   }
+  return ServiceResponse.failure(`${error}`, StatusCodes.INTERNAL_SERVER_ERROR)
 }
 
 function parseRequest(request: Request): SwapParams {

src/server.ts

@@ -28,7 +28,7 @@ app.use(requestLogger)
 
 // Routes
 app.use("/health-check", healthCheckRouter)
-app.use("/swap", swapRouter)
+app.use(swapRouter)
 
 // Swagger UI
 app.use(openAPIRouter)

src/swapService/runner.ts

@@ -1,4 +1,6 @@
+import { SwapResponse } from "@/api/routes/swap/swapModel"
 import { StatusCodes } from "http-status-codes"
+import { isHex } from "viem"
 import { getRoutingConfig } from "./config"
 import type {
   ChainRoutingConfig,
@@ -7,7 +9,7 @@ import type {
 } from "./interface"
 import { strategies } from "./strategies/index"
 import type { StrategyResult, SwapParams } from "./types"
-import { ApiError } from "./utils"
+import { ApiError, addInOutDeposits } from "./utils"
 
 function loadPipeline(swapParams: SwapParams) {
   let routing: ChainRoutingConfig
@@ -32,14 +34,14 @@ function loadPipeline(swapParams: SwapParams) {
 
 export async function runPipeline(
   swapParams: SwapParams,
-): Promise<SwapApiResponse> {
+): Promise<SwapApiResponse[]> {
   const pipeline = loadPipeline(swapParams)
 
   const allResults: StrategyResult[] = []
   for (const strategy of pipeline) {
     const result = await strategy.findSwap(swapParams)
     allResults.push(result)
-    if (result.response) break
+    if (result.quotes) break
   }
 
   console.log(allResults)
@@ -50,16 +52,43 @@ export async function runPipeline(
       StatusCodes.NOT_FOUND,
       "Pipeline empty or result not found",
     )
-  if (!finalResult.response) {
+  if (!finalResult.quotes || finalResult.quotes.length === 0) {
     throw new ApiError(
       StatusCodes.NOT_FOUND,
       "Swap quote not found",
       allResults,
     )
   }
 
-  // console.log('finalResult.response: ', JSON.stringify(finalResult.response, null, 2));
-  return finalResult.response
+  console.log("Best quote", {
+    amountIn: finalResult.quotes[0].amountIn,
+    amountInMax: finalResult.quotes[0].amountInMax,
+    amountOut: finalResult.quotes[0].amountOut,
+    amountOutMin: finalResult.quotes[0].amountOutMin,
+    route: finalResult.quotes[0].route,
+  })
+
+  // console.log('finalResult.quotes: ', JSON.stringify(finalResult.quotes, null, 2));
+  return finalResult.quotes
+}
+
+export async function findSwaps(swapParams: SwapParams) {
+  // GLOBAL CHECKS
+  let quotes = await runPipeline(swapParams)
+
+  // make sure verify item includes at least a function selector
+  quotes = quotes.filter(
+    (q) => isHex(q.verify.verifierData) && q.verify.verifierData.length >= 10,
+  )
+
+  if (quotes.length === 0)
+    throw new ApiError(StatusCodes.INTERNAL_SERVER_ERROR, "Invalid quotes")
+
+  for (const quote of quotes) {
+    addInOutDeposits(swapParams, quote)
+  }
+
+  return quotes
 }
 
 // TODO timeouts on balmy