@morpho-dev/router 0.1.16 → 0.1.17

package/dist/cli.js

@@ -10,17 +10,17 @@ import { spawn } from 'child_process';
 import 'fs';
 import { privateKeyToAccount, generatePrivateKey } from 'viem/accounts';
 import * as z6 from 'zod';
-import { Base64 } from 'js-base64';
 import { readFile } from 'fs/promises';
 import dotenv from 'dotenv';
 import { AsyncLocalStorage } from 'async_hooks';
 import { serve as serve$1 } from '@hono/node-server';
 import { Hono } from 'hono';
 import { cors } from 'hono/cors';
-import { asc, desc, and, eq, gt, gte, sql, lte, inArray } from 'drizzle-orm';
-import { pgSchema, integer, varchar, bigint, timestamp, text, boolean, numeric, index, primaryKey, uniqueIndex } from 'drizzle-orm/pg-core';
 import { z } from 'zod/v4';
 import { createDocument } from 'zod-openapi';
+import { Base64 } from 'js-base64';
+import { asc, desc, and, eq, gt, gte, sql, lte, inArray } from 'drizzle-orm';
+import { pgSchema, integer, varchar, bigint, timestamp, text, boolean, numeric, index, primaryKey, uniqueIndex } from 'drizzle-orm/pg-core';
 import { PGlite } from '@electric-sql/pglite';
 import { drizzle } from 'drizzle-orm/node-postgres';
 import { migrate } from 'drizzle-orm/node-postgres/migrator';
@@ -41,7 +41,7 @@ var __export = (target, all) => {
 // package.json
 var package_default = {
   name: "@morpho-dev/router",
-  version: "0.1.16",
+  version: "0.1.17",
   description: "Router package for Morpho protocol"};
 
 // src/core/Chain.ts
@@ -727,97 +727,6 @@ var from2 = (parameters) => {
   };
 };
 
-// src/core/Cursor.ts
-var Cursor_exports = {};
-__export(Cursor_exports, {
-  decode: () => decode,
-  encode: () => encode,
-  validate: () => validate
-});
-function validate(cursor) {
-  if (!cursor || typeof cursor !== "object") {
-    throw new Error("Cursor must be an object");
-  }
-  const c = cursor;
-  if (!["rate", "maturity", "expiry", "amount"].includes(c.sort)) {
-    throw new Error(
-      `Invalid sort field: ${c.sort}. Must be one of: rate, maturity, expiry, amount`
-    );
-  }
-  if (!["asc", "desc"].includes(c.dir)) {
-    throw new Error(`Invalid direction: ${c.dir}. Must be one of: asc, desc`);
-  }
-  if (!/^0x[a-fA-F0-9]{64}$/.test(c.hash)) {
-    throw new Error(
-      `Invalid hash format: ${c.hash}. Must be a 64-character hex string starting with 0x`
-    );
-  }
-  const validations = {
-    rate: {
-      field: "rate",
-      type: "string",
-      pattern: /^\d+$/,
-      error: "numeric string"
-    },
-    amount: {
-      field: "assets",
-      type: "string",
-      pattern: /^\d+$/,
-      error: "numeric string"
-    },
-    maturity: {
-      field: "maturity",
-      type: "number",
-      validator: (val) => val > 0,
-      error: "positive number"
-    },
-    expiry: {
-      field: "expiry",
-      type: "number",
-      validator: (val) => val > 0,
-      error: "positive number"
-    }
-  };
-  const validation = validations[c.sort];
-  if (!validation) {
-    throw new Error(`Invalid sort field: ${c.sort}`);
-  }
-  const fieldValue = c[validation.field];
-  if (!fieldValue) {
-    throw new Error(`${c.sort} sort requires '${validation.field}' field to be present`);
-  }
-  if (typeof fieldValue !== validation.type) {
-    throw new Error(
-      `${c.sort} sort requires '${validation.field}' field of type ${validation.type}`
-    );
-  }
-  if (validation.pattern && !validation.pattern.test(fieldValue)) {
-    throw new Error(
-      `Invalid ${validation.field} format: ${fieldValue}. Must be a ${validation.error}`
-    );
-  }
-  if (validation.validator && !validation.validator(fieldValue)) {
-    throw new Error(
-      `Invalid ${validation.field} value: ${fieldValue}. Must be a ${validation.error}`
-    );
-  }
-  if (c.page !== void 0) {
-    if (typeof c.page !== "number" || !Number.isInteger(c.page) || c.page < 1) {
-      throw new Error("Invalid page: must be a positive integer");
-    }
-  }
-  return true;
-}
-function encode(c) {
-  return Base64.encodeURL(JSON.stringify(c));
-}
-function decode(token) {
-  if (!token) return null;
-  const decoded = JSON.parse(Base64.decode(token));
-  validate(decoded);
-  return decoded;
-}
-
 // src/core/Liquidity.ts
 var Liquidity_exports = {};
 __export(Liquidity_exports, {
@@ -1133,9 +1042,9 @@ __export(Offer_exports, {
   OfferHashSchema: () => OfferHashSchema,
   OfferSchema: () => OfferSchema,
   consumedEvent: () => consumedEvent,
-  decode: () => decode2,
+  decode: () => decode,
   domain: () => domain,
-  encode: () => encode2,
+  encode: () => encode,
   from: () => from5,
   fromConsumedLog: () => fromConsumedLog,
   fromSnakeCase: () => fromSnakeCase3,
@@ -1460,7 +1369,7 @@ var OfferAbi = [
   },
   { name: "signature", type: "bytes" }
 ];
-function encode2(offer) {
+function encode(offer) {
   return encodeAbiParameters(OfferAbi, [
     offer.offering,
     offer.assets,
@@ -1477,7 +1386,7 @@ function encode2(offer) {
     offer.signature ?? "0x"
   ]);
 }
-function decode2(data, blockNumber) {
+function decode(data, blockNumber) {
   let decoded;
   try {
     decoded = decodeAbiParameters(OfferAbi, data);
@@ -1547,6 +1456,57 @@ var AccountNotSetError = class extends BaseError {
   }
 };
 
+// src/core/Quote.ts
+var Quote_exports = {};
+__export(Quote_exports, {
+  InvalidQuoteError: () => InvalidQuoteError,
+  QuoteSchema: () => QuoteSchema,
+  from: () => from6,
+  fromSnakeCase: () => fromSnakeCase4,
+  random: () => random3
+});
+var QuoteSchema = z6.object({
+  obligationId: z6.string().transform(transformHex),
+  ask: z6.object({
+    rate: z6.bigint({ coerce: true }).min(0n).max(maxUint256)
+  }),
+  bid: z6.object({
+    rate: z6.bigint({ coerce: true }).min(0n).max(maxUint256)
+  })
+});
+function from6(parameters) {
+  try {
+    const parsedQuote = QuoteSchema.parse(parameters);
+    return {
+      obligationId: parsedQuote.obligationId,
+      ask: parsedQuote.ask,
+      bid: parsedQuote.bid
+    };
+  } catch (error2) {
+    throw new InvalidQuoteError(error2);
+  }
+}
+function fromSnakeCase4(snake) {
+  return from6(fromSnakeCase(snake));
+}
+function random3() {
+  return from6({
+    obligationId: Obligation_exports.id(Obligation_exports.random()),
+    ask: {
+      rate: BigInt(Math.floor(Math.random() * 1e6))
+    },
+    bid: {
+      rate: BigInt(Math.floor(Math.random() * 1e6))
+    }
+  });
+}
+var InvalidQuoteError = class extends BaseError {
+  name = "Quote.InvalidQuoteError";
+  constructor(error2) {
+    super("Invalid quote.", { cause: error2 });
+  }
+};
+
 // src/evm/EVM.ts
 var users = [
   privateKeyToAccount(
@@ -1663,11 +1623,16 @@ function defaultLogger(minLevel, pretty) {
       return;
     }
     const { msg, ...rest } = entry;
+    const stack = typeof rest.stack === "string" ? rest.stack : void 0;
+    if (stack) delete rest.stack;
     const timestamp2 = (/* @__PURE__ */ new Date()).toISOString();
     const level = methodLevel.toUpperCase();
     const extras = Object.entries(rest).map(([k, v]) => `${k}=${formatValue(v)}`).join(" ");
     const line = extras.length > 0 ? `${timestamp2} [${level}] ${msg}  ${extras}` : `${timestamp2} [${level}] ${msg}`;
     console[consoleMethod](line);
+    if (stack) {
+      console[consoleMethod](stack);
+    }
   } : () => {
   };
   return {
@@ -1709,6 +1674,442 @@ function formatValue(value) {
     }
   }
 }
+var CollectorHealth = z.object({
+  name: z.string(),
+  chain_id: z.number(),
+  block_number: z.number().nullable(),
+  updated_at: z.string().nullable(),
+  lag: z.number().nullable(),
+  status: z.enum(["live", "lagging", "unknown"])
+});
+var CollectorsHealthResponse = z.array(CollectorHealth);
+var ChainHealth = z.object({
+  chain_id: z.number(),
+  block_number: z.number(),
+  updated_at: z.string()
+});
+var ChainsHealthResponse = z.array(ChainHealth);
+var RouterStatusResponse = z.object({
+  status: z.enum(["live", "syncing"])
+});
+
+// src/stores/utils/Cursor.ts
+var Cursor_exports = {};
+__export(Cursor_exports, {
+  decode: () => decode2,
+  encode: () => encode2,
+  validate: () => validate
+});
+function validate(cursor) {
+  if (!cursor || typeof cursor !== "object") {
+    throw new Error("Cursor must be an object");
+  }
+  const c = cursor;
+  if (!["rate", "maturity", "expiry", "amount"].includes(c.sort)) {
+    throw new Error(
+      `Invalid sort field: ${c.sort}. Must be one of: rate, maturity, expiry, amount`
+    );
+  }
+  if (!["asc", "desc"].includes(c.dir)) {
+    throw new Error(`Invalid direction: ${c.dir}. Must be one of: asc, desc`);
+  }
+  if (!/^0x[a-fA-F0-9]{64}$/.test(c.hash)) {
+    throw new Error(
+      `Invalid hash format: ${c.hash}. Must be a 64-character hex string starting with 0x`
+    );
+  }
+  const validations = {
+    rate: {
+      field: "rate",
+      type: "string",
+      pattern: /^\d+$/,
+      error: "numeric string"
+    },
+    amount: {
+      field: "assets",
+      type: "string",
+      pattern: /^\d+$/,
+      error: "numeric string"
+    },
+    maturity: {
+      field: "maturity",
+      type: "number",
+      validator: (val) => val > 0,
+      error: "positive number"
+    },
+    expiry: {
+      field: "expiry",
+      type: "number",
+      validator: (val) => val > 0,
+      error: "positive number"
+    }
+  };
+  const validation = validations[c.sort];
+  if (!validation) {
+    throw new Error(`Invalid sort field: ${c.sort}`);
+  }
+  const fieldValue = c[validation.field];
+  if (!fieldValue) {
+    throw new Error(`${c.sort} sort requires '${validation.field}' field to be present`);
+  }
+  if (typeof fieldValue !== validation.type) {
+    throw new Error(
+      `${c.sort} sort requires '${validation.field}' field of type ${validation.type}`
+    );
+  }
+  if (validation.pattern && !validation.pattern.test(fieldValue)) {
+    throw new Error(
+      `Invalid ${validation.field} format: ${fieldValue}. Must be a ${validation.error}`
+    );
+  }
+  if (validation.validator && !validation.validator(fieldValue)) {
+    throw new Error(
+      `Invalid ${validation.field} value: ${fieldValue}. Must be a ${validation.error}`
+    );
+  }
+  if (c.page !== void 0) {
+    if (typeof c.page !== "number" || !Number.isInteger(c.page) || c.page < 1) {
+      throw new Error("Invalid page: must be a positive integer");
+    }
+  }
+  return true;
+}
+function encode2(c) {
+  return Base64.encodeURL(JSON.stringify(c));
+}
+function decode2(token) {
+  if (!token) return null;
+  const decoded = JSON.parse(Base64.decode(token));
+  validate(decoded);
+  return decoded;
+}
+
+// src/api/Schema/requests.ts
+var MAX_LIMIT = 100;
+var DEFAULT_LIMIT = 20;
+var PaginationQueryParams = z6.object({
+  cursor: z6.string().optional().refine(
+    (val) => {
+      if (!val) return true;
+      try {
+        const decoded = Cursor_exports.decode(val);
+        return decoded !== null;
+      } catch (_error) {
+        return false;
+      }
+    },
+    {
+      message: "Invalid cursor format. Must be a valid base64url-encoded cursor object"
+    }
+  ).meta({
+    description: "Pagination cursor in base64url-encoded format",
+    example: "eyJzb3J0IjoicHJpY2UiLCJkaXIiOiJkZXNjIiwicHJpY2UiOiIxMDAwMDAwMDAwMDAwMDAwMDAwIiwiaGFzaCI6IjB4ZGRmZDY4NTllM2UwODJkMTkzODlhMWFlYzFiZGFkN2U4ZDkyZDk2YjFhYTc5NDBkYTkxYTMxMjVkMzFlM2JlNWIifQ"
+  }),
+  limit: z6.string().regex(/^[1-9]\d*$/, {
+    message: "Limit must be a positive integer"
+  }).transform((val) => Number.parseInt(val, 10)).pipe(
+    z6.number().max(MAX_LIMIT, {
+      message: `Limit cannot exceed ${MAX_LIMIT}`
+    })
+  ).optional().default(DEFAULT_LIMIT).meta({
+    description: `Limit maximum: ${MAX_LIMIT}. Default: ${DEFAULT_LIMIT}`,
+    example: 10
+  })
+});
+var GetOffersQueryParams = z6.object({
+  ...PaginationQueryParams.shape,
+  side: z6.enum(["buy", "sell"]).meta({
+    description: "Side of the offer.",
+    example: "buy"
+  }),
+  obligation_id: z6.string({ error: "Obligation id is required and must be a valid 32-byte hex string" }).regex(/^0x[a-fA-F0-9]{64}$/, { error: "Obligation id must be a valid 32-byte hex string" }).transform((val) => val.toLowerCase()).meta({
+    description: "Offers obligation id",
+    example: "0x1234567890123456789012345678901234567890123456789012345678901234"
+  })
+});
+var GetObligationsQueryParams = z6.object({
+  ...PaginationQueryParams.shape,
+  cursor: z6.string().optional().meta({
+    description: "Obligation id cursor",
+    example: "0x1234567890123456789012345678901234567890123456789012345678901234"
+  })
+});
+var schemas = {
+  get_offers: GetOffersQueryParams,
+  get_obligations: GetObligationsQueryParams
+};
+function safeParse(action, query, error2) {
+  return schemas[action].safeParse(query, {
+    error: error2
+  });
+}
+
+// src/api/Schema/openapi.ts
+var timestampExample = "2024-01-01T12:00:00.000Z";
+var cursorExample = "eyJvZmZzZXQiOjEwMH0";
+function makeSuccessResponse(parameters) {
+  const { dataSchema, dataDescription, dataExample, cursor } = parameters;
+  const withDataMeta = dataDescription ? dataSchema.meta({ description: dataDescription }) : dataSchema;
+  return z.object({
+    status: z.literal("success"),
+    cursor: z.string().nullable(),
+    data: z.any(),
+    meta: z.object({
+      timestamp: z.string()
+    })
+  }).extend({
+    data: withDataMeta
+  }).meta({
+    example: {
+      status: "success",
+      cursor,
+      data: dataExample,
+      meta: { timestamp: timestampExample }
+    }
+  });
+}
+var OffersSuccessResponseSchema = makeSuccessResponse({
+  dataSchema: z.array(z.any()),
+  dataDescription: "Offers matching the provided filters.",
+  dataExample: [toSnakeCase(Offer_exports.random())],
+  cursor: cursorExample
+});
+var ObligationsSuccessResponseSchema = makeSuccessResponse({
+  dataSchema: z.array(z.any()),
+  dataDescription: "Obligations known to the router.",
+  dataExample: [toSnakeCase(Obligation_exports.random())],
+  cursor: cursorExample
+});
+var RouterStatusSuccessResponseSchema = makeSuccessResponse({
+  dataSchema: RouterStatusResponse,
+  dataDescription: "Aggregated router status.",
+  dataExample: { status: "live" },
+  cursor: null
+});
+var CollectorsHealthSuccessResponseSchema = makeSuccessResponse({
+  dataSchema: CollectorsHealthResponse,
+  dataDescription: "Collectors health details and sync status.",
+  dataExample: [
+    {
+      name: "mempool_offers",
+      chain_id: "1",
+      block_number: 21345678,
+      updated_at: "2024-01-01T12:00:00.000Z",
+      lag: 0,
+      status: "live"
+    }
+  ],
+  cursor: null
+});
+var ChainsHealthSuccessResponseSchema = makeSuccessResponse({
+  dataSchema: ChainsHealthResponse,
+  dataDescription: "Latest processed block per chain.",
+  dataExample: [
+    {
+      chain_id: "1",
+      block_number: 21345678,
+      updated_at: "2024-01-01T12:00:00.000Z"
+    }
+  ],
+  cursor: null
+});
+var errorResponseSchema = z.object({
+  status: z.literal("error"),
+  error: z.object({
+    code: z.string(),
+    message: z.string(),
+    details: z.any().optional()
+  }),
+  meta: z.object({
+    timestamp: z.string()
+  })
+}).meta({
+  description: "Error response wrapper.",
+  example: {
+    status: "error",
+    error: {
+      code: "VALIDATION_ERROR",
+      message: "Invalid cursor format. Must be a valid base64url-encoded cursor object",
+      details: [
+        {
+          field: "cursor",
+          issue: "Invalid cursor format. Must be a valid base64url-encoded cursor object"
+        }
+      ]
+    },
+    meta: {
+      timestamp: timestampExample
+    }
+  }
+});
+var paths = {
+  "/v1/offers": {
+    get: {
+      summary: "Offers",
+      description: "Find offers that match specific criteria",
+      tags: ["Offers"],
+      requestParams: {
+        query: GetOffersQueryParams
+      },
+      responses: {
+        200: {
+          description: "Success",
+          content: {
+            "application/json": {
+              schema: OffersSuccessResponseSchema
+            }
+          }
+        },
+        400: {
+          description: "Bad Request",
+          content: {
+            "application/json": {
+              schema: errorResponseSchema
+            }
+          }
+        }
+      }
+    }
+  },
+  "/v1/obligations": {
+    get: {
+      summary: "Obligations",
+      description: "List obligations with pagination support",
+      tags: ["Obligations"],
+      requestParams: {
+        query: GetObligationsQueryParams
+      },
+      responses: {
+        200: {
+          description: "Success",
+          content: {
+            "application/json": {
+              schema: ObligationsSuccessResponseSchema
+            }
+          }
+        },
+        400: {
+          description: "Bad Request",
+          content: {
+            "application/json": {
+              schema: errorResponseSchema
+            }
+          }
+        }
+      }
+    }
+  },
+  "/v1/health": {
+    get: {
+      summary: "Router status",
+      description: "Retrieve the aggregated status of the router.",
+      tags: ["Health"],
+      responses: {
+        200: {
+          description: "Success",
+          content: {
+            "application/json": {
+              schema: RouterStatusSuccessResponseSchema
+            }
+          }
+        }
+      }
+    }
+  },
+  "/v1/health/collectors": {
+    get: {
+      summary: "Collectors health",
+      description: "Retrieve the block numbers processed by collectors and their sync status.",
+      tags: ["Health"],
+      responses: {
+        200: {
+          description: "Success",
+          content: {
+            "application/json": {
+              schema: CollectorsHealthSuccessResponseSchema
+            }
+          }
+        }
+      }
+    }
+  },
+  "/v1/health/chains": {
+    get: {
+      summary: "Chains health",
+      description: "Retrieve the latest block processed for each chain.",
+      tags: ["Health"],
+      responses: {
+        200: {
+          description: "Success",
+          content: {
+            "application/json": {
+              schema: ChainsHealthSuccessResponseSchema
+            }
+          }
+        }
+      }
+    }
+  }
+};
+var OpenApi = createDocument({
+  openapi: "3.1.0",
+  info: {
+    title: "Router API",
+    version: "1.0.0",
+    description: "API for the Morpho Router"
+  },
+  tags: [
+    {
+      name: "Offers"
+    },
+    {
+      name: "Obligations"
+    },
+    {
+      name: "Health"
+    }
+  ],
+  servers: [
+    {
+      url: "https://router.morpho.dev",
+      description: "Production server"
+    },
+    {
+      url: "http://localhost:7891",
+      description: "Local development server"
+    }
+  ],
+  paths
+});
+
+// src/api/Controllers/getDocs.ts
+function getSwaggerJson() {
+  return OpenApi;
+}
+function getDocsHtml() {
+  const html = `<!DOCTYPE html>
+<html>
+  <head>
+    <meta charset="UTF-8">
+    <title>Router API Docs (Scalar)</title>
+    <script src="https://cdn.jsdelivr.net/npm/@scalar/api-reference"></script>
+    <style>
+      html, body { margin: 0; height: 100%; }
+      api-reference { height: 100%; width: 100%; }
+    </style>
+  </head>
+  <body>
+    <div id="api-container" style="height:100%;width:100%;"></div>
+    <script>
+      window.addEventListener('load', function () {
+        const spec = ${JSON.stringify(OpenApi)};
+        Scalar.createApiReference('#api-container', { spec: { content: spec } });
+      });
+    </script>
+  </body>
+</html>`;
+  return html;
+}
 
 // src/collectors/index.ts
 var collectors_exports = {};
@@ -1991,20 +2392,31 @@ function create2({
       });
       return poll(
         async () => {
-          let { blockNumber: lastBlockNumber, epoch } = await collectorStore.getBlockNumber({
-            collectorName: name,
-            chainId: chain.id
-          });
-          await admin.syncBlock();
-          lastBlockNumber = await collect({
-            chain,
-            client,
-            collector: name,
-            epoch,
-            lastBlockNumber,
-            withTransaction
-          });
-          emit(lastBlockNumber);
+          try {
+            let { blockNumber: lastBlockNumber, epoch } = await collectorStore.getBlockNumber({
+              collectorName: name,
+              chainId: chain.id
+            });
+            await admin.syncBlock();
+            lastBlockNumber = await collect({
+              chain,
+              client,
+              collector: name,
+              epoch,
+              lastBlockNumber,
+              withTransaction
+            });
+            emit(lastBlockNumber);
+          } catch (err) {
+            const isError = err instanceof Error;
+            logger.error({
+              msg: "Collector error",
+              collector,
+              chain_id: chain.id,
+              error: isError ? err.message : String(err),
+              stack: isError ? err.stack : void 0
+            });
+          }
         },
         { interval: options.interval }
       );
@@ -2024,7 +2436,7 @@ function start(collector) {
 }
 var DEFAULT_BATCH_SIZE2 = 100;
 var DEFAULT_BLOCK_WINDOW2 = 100;
-function from6(parameters) {
+function from7(parameters) {
   const config = {
     client: parameters.client,
     mempoolAddress: parameters.mempoolAddress,
@@ -2166,7 +2578,7 @@ var ChainIdMismatchError = class extends BaseError {
 
 // src/mempool/MempoolClient.ts
 function connect(parameters) {
-  return from6(parameters);
+  return from7(parameters);
 }
 
 // src/stores/CollectorStore.ts
@@ -4006,7 +4418,7 @@ function handleZodError(error2) {
   return new ValidationError("Validation failed", formattedErrors);
 }
 
-// src/api/Api/Controllers/getHealth.ts
+// src/api/Controllers/getHealth.ts
 async function getHealth(healthService) {
   const logger = Logger_exports.getLogger();
   try {
@@ -4071,266 +4483,31 @@ async function getHealthCollectors(healthService) {
     return error(err);
   }
 }
-var CollectorHealth = z.object({
-  name: z.string(),
-  chain_id: z.number(),
-  block_number: z.number().nullable(),
-  updated_at: z.string().nullable(),
-  lag: z.number().nullable(),
-  status: z.enum(["live", "lagging", "unknown"])
-});
-var CollectorsHealthResponse = z.object({
-  collectors: z.array(CollectorHealth)
-});
-var ChainHealth = z.object({
-  chain_id: z.number(),
-  block_number: z.number(),
-  updated_at: z.string()
-});
-var ChainsHealthResponse = z.object({
-  chains: z.array(ChainHealth)
-});
-var RouterStatusResponse = z.object({
-  status: z.enum(["live", "syncing"])
-});
 
-// src/api/Api/Schema/ObligationResponse.ts
+// src/api/Schema/ObligationResponse.ts
 var ObligationResponse_exports = {};
 __export(ObligationResponse_exports, {
-  from: () => from7
+  from: () => from8
 });
-function from7(obligation) {
-  return toSnakeCase({ id: Obligation_exports.id(obligation), ...obligation });
+function from8(obligation, quote) {
+  return toSnakeCase({
+    id: quote.obligationId,
+    ...obligation,
+    ask: quote.ask,
+    bid: quote.bid
+  });
 }
 
-// src/api/Api/Schema/OfferResponse.ts
+// src/api/Schema/OfferResponse.ts
 var OfferResponse_exports = {};
 __export(OfferResponse_exports, {
-  from: () => from8
+  from: () => from9
 });
-function from8(offer) {
+function from9(offer) {
   return toSnakeCase(offer);
 }
-var MAX_LIMIT = 100;
-var DEFAULT_LIMIT = 20;
-var PaginationQueryParams = z6.object({
-  cursor: z6.string().optional().refine(
-    (val) => {
-      if (!val) return true;
-      try {
-        const decoded = Cursor_exports.decode(val);
-        return decoded !== null;
-      } catch (_error) {
-        return false;
-      }
-    },
-    {
-      message: "Invalid cursor format. Must be a valid base64url-encoded cursor object"
-    }
-  ).meta({
-    description: "Pagination cursor in base64url-encoded format",
-    example: "eyJzb3J0IjoicHJpY2UiLCJkaXIiOiJkZXNjIiwicHJpY2UiOiIxMDAwMDAwMDAwMDAwMDAwMDAwIiwiaGFzaCI6IjB4ZGRmZDY4NTllM2UwODJkMTkzODlhMWFlYzFiZGFkN2U4ZDkyZDk2YjFhYTc5NDBkYTkxYTMxMjVkMzFlM2JlNWIifQ"
-  }),
-  limit: z6.string().regex(/^[1-9]\d*$/, {
-    message: "Limit must be a positive integer"
-  }).transform((val) => Number.parseInt(val, 10)).pipe(
-    z6.number().max(MAX_LIMIT, {
-      message: `Limit cannot exceed ${MAX_LIMIT}`
-    })
-  ).optional().default(DEFAULT_LIMIT).meta({
-    description: `Limit maximum: ${MAX_LIMIT}. Default: ${DEFAULT_LIMIT}`,
-    example: 10
-  })
-});
-var GetOffersQueryParams = z6.object({
-  ...PaginationQueryParams.shape,
-  side: z6.enum(["buy", "sell"]).meta({
-    description: "Side of the offer.",
-    example: "buy"
-  }),
-  obligation_id: z6.string({ error: "Obligation id is required and must be a valid 32-byte hex string" }).regex(/^0x[a-fA-F0-9]{64}$/, { error: "Obligation id must be a valid 32-byte hex string" }).transform((val) => val.toLowerCase()).meta({
-    description: "Offers obligation id",
-    example: "0x1234567890123456789012345678901234567890123456789012345678901234"
-  })
-});
-var GetObligationsQueryParams = z6.object({
-  ...PaginationQueryParams.shape,
-  cursor: z6.string().optional().meta({
-    description: "Obligation id cursor",
-    example: "0x1234567890123456789012345678901234567890123456789012345678901234"
-  })
-});
-var schemas = {
-  get_offers: GetOffersQueryParams,
-  get_obligations: GetObligationsQueryParams
-};
-function safeParse(action, query, error2) {
-  return schemas[action].safeParse(query, {
-    error: error2
-  });
-}
-
-// src/api/Api/Schema/openapi.ts
-var successResponseSchema = z.object({
-  status: z.literal("success"),
-  cursor: z.string().nullable(),
-  data: z.array(z.any()),
-  meta: z.object({
-    timestamp: z.string()
-  })
-});
-var errorResponseSchema = z.object({
-  status: z.literal("error"),
-  error: z.object({
-    code: z.string(),
-    message: z.string(),
-    details: z.any().optional()
-  }),
-  meta: z.object({
-    timestamp: z.string()
-  })
-});
-var paths = {
-  "/v1/offers": {
-    get: {
-      summary: "Offers",
-      description: "Find offers that match specific criteria",
-      tags: ["Offers"],
-      requestParams: {
-        query: GetOffersQueryParams
-      },
-      responses: {
-        200: {
-          description: "Success",
-          content: {
-            "application/json": {
-              schema: successResponseSchema
-            }
-          }
-        },
-        400: {
-          description: "Bad Request",
-          content: {
-            "application/json": {
-              schema: errorResponseSchema
-            }
-          }
-        }
-      }
-    }
-  },
-  "/v1/obligations": {
-    get: {
-      summary: "Obligations",
-      description: "List obligations with pagination support",
-      tags: ["Obligations"],
-      requestParams: {
-        query: GetObligationsQueryParams
-      },
-      responses: {
-        200: {
-          description: "Success",
-          content: {
-            "application/json": {
-              schema: successResponseSchema
-            }
-          }
-        },
-        400: {
-          description: "Bad Request",
-          content: {
-            "application/json": {
-              schema: errorResponseSchema
-            }
-          }
-        }
-      }
-    }
-  },
-  "/v1/health": {
-    get: {
-      summary: "Router status",
-      description: "Retrieve the aggregated status of the router.",
-      tags: ["Health"],
-      responses: {
-        200: {
-          description: "Success",
-          content: {
-            "application/json": {
-              schema: RouterStatusResponse
-            }
-          }
-        }
-      }
-    }
-  },
-  "/v1/health/collectors": {
-    get: {
-      summary: "Collectors health",
-      description: "Retrieve the block numbers processed by collectors and their sync status.",
-      tags: ["Health"],
-      responses: {
-        200: {
-          description: "Success",
-          content: {
-            "application/json": {
-              schema: CollectorsHealthResponse
-            }
-          }
-        }
-      }
-    }
-  },
-  "/v1/health/chains": {
-    get: {
-      summary: "Chains health",
-      description: "Retrieve the latest block processed for each chain.",
-      tags: ["Health"],
-      responses: {
-        200: {
-          description: "Success",
-          content: {
-            "application/json": {
-              schema: ChainsHealthResponse
-            }
-          }
-        }
-      }
-    }
-  }
-};
-createDocument({
-  openapi: "3.1.0",
-  info: {
-    title: "Router API",
-    version: "1.0.0",
-    description: "API for the Morpho Router"
-  },
-  tags: [
-    {
-      name: "Offers"
-    },
-    {
-      name: "Obligations"
-    },
-    {
-      name: "Health"
-    }
-  ],
-  servers: [
-    {
-      url: "https://router.morpho.dev",
-      description: "Production server"
-    },
-    {
-      url: "http://localhost:8081",
-      description: "Local development server"
-    }
-  ],
-  paths
-});
 
-// src/api/Api/Controllers/getObligations.ts
+// src/api/Controllers/getObligations.ts
 async function getObligations(queryParameters, store) {
   const logger = Logger_exports.getLogger();
   const result = safeParse("get_obligations", queryParameters, (issue) => issue.message);
@@ -4341,8 +4518,20 @@ async function getObligations(queryParameters, store) {
       cursor: query.cursor,
       limit: query.limit
     });
+    const quotes = await store.getQuotes({
+      obligationIds: obligations2.map((o) => Obligation_exports.id(o))
+    });
     return success({
-      data: obligations2.map((o) => ObligationResponse_exports.from(o)),
+      data: obligations2.map(
+        (o) => ObligationResponse_exports.from(
+          o,
+          quotes.find((q) => q.obligationId === Obligation_exports.id(o)) ?? {
+            obligationId: Obligation_exports.id(o),
+            ask: { rate: 0n },
+            bid: { rate: 0n }
+          }
+        )
+      ),
       cursor: nextCursor ?? null
     });
   } catch (err) {
@@ -4356,7 +4545,7 @@ async function getObligations(queryParameters, store) {
   }
 }
 
-// src/api/Api/Controllers/getOffers.ts
+// src/api/Controllers/getOffers.ts
 async function getOffers(queryParameters, store) {
   const logger = Logger_exports.getLogger();
   const result = safeParse("get_offers", queryParameters, (issue) => issue.message);
@@ -4384,7 +4573,7 @@ async function getOffers(queryParameters, store) {
   }
 }
 
-// src/api/Api/Api.ts
+// src/api/Api.ts
 function create5(config) {
   return {
     serve: ({ port }) => {
@@ -4416,6 +4605,13 @@ function serve2(parameters) {
     const { statusCode, body } = await getHealthChains(healthService);
     return c.json(body, statusCode);
   });
+  app.get(
+    "/docs/swagger.json",
+    (c) => c.text(JSON.stringify(getSwaggerJson()), 200, {
+      "Content-Type": "application/json; charset=utf-8"
+    })
+  );
+  app.get("/docs", (c) => c.html(getDocsHtml(), 200));
   serve$1({
     fetch: app.fetch,
     port: parameters.port
@@ -5036,6 +5232,64 @@ function create8(config) {
       const returnedItems = Array.from(items.values());
       const nextCursor = returnedItems.length === limit && returnedItems.length > 0 ? result[result.length - 1].obligationId : null;
       return { obligations: returnedItems, nextCursor };
+    },
+    getQuotes: async (parameters) => {
+      const { obligationIds } = parameters;
+      if (obligationIds.length === 0) return [];
+      const now2 = time_exports.now();
+      const sumConsumed = db.select({
+        consumed: sql`COALESCE(SUM(${consumed.consumed}), 0)`.as("consumed")
+      }).from(consumed).where(
+        and(
+          eq(consumed.offering, offers.offering),
+          eq(consumed.nonce, offers.nonce),
+          eq(consumed.chainId, offers.chainId)
+        )
+      ).as("sum_consumed");
+      const remaining = sql`(${offers.assets} - COALESCE(${sumConsumed.consumed}, 0))`;
+      const query = ({ side }) => db.selectDistinctOn([offers.obligationId], {
+        obligationId: offers.obligationId,
+        rate: offers.rate
+      }).from(offers).leftJoinLateral(sumConsumed, sql`true`).where(
+        and(
+          inArray(offers.obligationId, obligationIds),
+          gte(offers.expiry, now2),
+          gte(offers.maturity, now2),
+          eq(offers.buy, side === "buy"),
+          sql`${remaining} > 0`
+        )
+      ).orderBy(
+        offers.obligationId,
+        // lower rates first for buy, higher rates first for sell
+        side === "buy" ? asc(offers.rate) : desc(offers.rate)
+      );
+      const [bestBuys, bestSells] = await Promise.all([
+        query({ side: "buy" }),
+        query({ side: "sell" })
+      ]);
+      const quotes = /* @__PURE__ */ new Map();
+      for (const row of bestSells) {
+        quotes.set(row.obligationId, {
+          ask: { rate: row.rate },
+          bid: { rate: 0n }
+        });
+      }
+      for (const row of bestBuys) {
+        const quote = quotes.get(row.obligationId);
+        if (!quote) {
+          quotes.set(row.obligationId, {
+            ask: { rate: 0n },
+            bid: { rate: row.rate }
+          });
+          continue;
+        }
+        quote.bid = { rate: row.rate };
+      }
+      return Array.from(quotes.entries()).map(([id2, quote]) => {
+        return Quote_exports.from({ obligationId: id2, ask: quote.ask, bid: quote.bid });
+      }).sort((a, b) => {
+        return a.obligationId.localeCompare(b.obligationId);
+      });
     }
   };
 }
@@ -5777,7 +6031,7 @@ function create9(params) {
 }
 
 // src/services/Services.ts
-function from9(config) {
+function from10(config) {
   const {
     chain,
     rpcUrl,
@@ -5905,7 +6159,7 @@ var RouterCmd = class _RouterCmd extends Command {
         "RPC URL is required, please set the ROUTER_RPC_URL environment variable or use --rpc-url <url> option."
       );
     }
-    const routerServices = from9({
+    const routerServices = from10({
       chain,
       rpcUrl,
       dbConfig: {