@morpho-dev/router 0.1.16 → 0.1.18

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.18",
   description: "Router package for Morpho protocol"};
 
 // src/core/Chain.ts
@@ -142,8 +142,12 @@ var chains = {
       [
         "0xA0b86991c6218b36c1d19D4a2e9Eb0cE3606eB48",
         // USDC
-        "0x6B175474E89094C44Da98b954EedeAC495271d0F"
+        "0x6B175474E89094C44Da98b954EedeAC495271d0F",
         // DAI
+        "0xC02aaA39b223FE8D0A0e5C4F27eAD9083C756Cc2",
+        // WETH
+        "0x2260FAC5E5542a773Aa44fBCfeDf7C193bc2C599"
+        // WBTC
       ].map((address) => address.toLowerCase())
     ),
     morpho: "0x0000000000000000000000000000000000000000",
@@ -166,8 +170,12 @@ var chains = {
       [
         "0x833589fCD6eDb6E08f4c7C32D4f71b54bdA02913",
         // USDC
-        "0x50c5725949A6F0c72E6C4a641F24049A917DB0Cb"
+        "0x50c5725949A6F0c72E6C4a641F24049A917DB0Cb",
         // DAI
+        "0x4200000000000000000000000000000000000006",
+        // WETH
+        "0x2260FAC5E5542a773Aa44fBCfeDf7C193bc2C599"
+        // WBTC
       ].map((address) => address.toLowerCase())
     ),
     morpho: "0x0000000000000000000000000000000000000000",
@@ -190,8 +198,12 @@ var chains = {
       [
         "0xA0b86991c6218b36c1d19D4a2e9Eb0cE3606eB48",
         // USDC
-        "0x6B175474E89094C44Da98b954EedeAC495271d0F"
+        "0x6B175474E89094C44Da98b954EedeAC495271d0F",
         // DAI
+        "0xC02aaA39b223FE8D0A0e5C4F27eAD9083C756Cc2",
+        // WETH
+        "0x2260FAC5E5542a773Aa44fBCfeDf7C193bc2C599"
+        // WBTC
       ].map((address) => address.toLowerCase())
     ),
     morpho: "0x11a002d45db720ed47a80d2f3489cba5b833eaf5",
@@ -215,8 +227,12 @@ var chains = {
       [
         "0xA0b86991c6218b36c1d19D4a2e9Eb0cE3606eB48",
         // USDC
-        "0x6B175474E89094C44Da98b954EedeAC495271d0F"
+        "0x6B175474E89094C44Da98b954EedeAC495271d0F",
         // DAI
+        "0xC02aaA39b223FE8D0A0e5C4F27eAD9083C756Cc2",
+        // WETH
+        "0x2260FAC5E5542a773Aa44fBCfeDf7C193bc2C599"
+        // WBTC
       ].map((address) => address.toLowerCase())
     ),
     morpho: "0x23DFBc4B8B80C14CC5e25011B8491f268395BAd6",
@@ -727,97 +743,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 +1058,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,
@@ -1306,39 +1231,92 @@ function fromSnakeCase3(input) {
 function toSnakeCase2(offer) {
   return toSnakeCase(offer);
 }
-function random2() {
-  const loanToken = privateKeyToAccount(generatePrivateKey()).address;
-  const maturity = from3("end_of_month");
-  const expiry = from3("end_of_week") - 1;
-  const lltv = from(0.965);
+function random2(config) {
+  const chain = config?.chains ? config.chains[Math.floor(Math.random() * config.chains.length)] : chains.ethereum;
+  const loanToken = config?.loanTokens ? config.loanTokens[Math.floor(Math.random() * config.loanTokens.length)] : privateKeyToAccount(generatePrivateKey()).address;
+  const collateralCandidates = config?.collateralTokens ? config.collateralTokens.filter((a) => a !== loanToken) : [privateKeyToAccount(generatePrivateKey()).address];
+  const collateralAsset = collateralCandidates[Math.floor(Math.random() * collateralCandidates.length)];
+  const maturityOption = weightedChoice([
+    ["end_of_month", 1],
+    ["end_of_next_month", 1]
+  ]);
+  const maturity = config?.maturity ?? from3(maturityOption);
+  const lltv = from(
+    weightedChoice([
+      [0.385, 1],
+      [0.5, 1],
+      [0.625, 2],
+      [0.77, 8],
+      [0.86, 10],
+      [0.915, 8],
+      [0.945, 6],
+      [0.965, 4],
+      [0.98, 2]
+    ])
+  );
+  const buy = config?.buy !== void 0 ? config.buy : Math.random() > 0.5;
+  const ONE = 1000000000000000000n;
+  const qMin = buy ? 16 : 4;
+  const qMax = buy ? 32 : 16;
+  const len = qMax - qMin + 1;
+  const ratePairs = Array.from(
+    { length: len },
+    (_, idx) => {
+      const q = qMin + idx;
+      const scaledRate = BigInt(q) * (ONE / 4n);
+      const weight = buy ? 1 + idx : 1 + (len - 1 - idx);
+      return [scaledRate, weight];
+    }
+  );
+  const rate = config?.rate ?? weightedChoice(ratePairs);
+  const loanTokenDecimals = config?.assetsDecimals?.[loanToken] ?? 18;
+  const unit = BigInt(10) ** BigInt(loanTokenDecimals);
+  const amountBase = BigInt(100 + Math.floor(Math.random() * (1e6 - 100 + 1)));
+  const assetsScaled = config?.assets ?? amountBase * unit;
+  const consumed2 = config?.consumed !== void 0 ? config.consumed : Math.random() < 0.8 ? 0n : assetsScaled * BigInt(1 + Math.floor(Math.random() * 900)) / 1000n;
+  const callbackBySide = (() => {
+    if (buy) return { address: zeroAddress, data: "0x", gasLimit: 0n };
+    const sellCallbackAddress = WhitelistedCallbackAddresses["sell_erc20_callback" /* SellERC20Callback */][0].toLowerCase();
+    const amount = assetsScaled * 1000000000000000000000n;
+    const data = encodeSellERC20Callback({
+      collaterals: [collateralAsset],
+      amounts: [amount]
+    });
+    return { address: sellCallbackAddress, data, gasLimit: 500000n };
+  })();
   const offer = from5({
-    offering: privateKeyToAccount(generatePrivateKey()).address,
-    assets: BigInt(Math.floor(Math.random() * 1e6)),
-    rate: BigInt(Math.floor(Math.random() * 1e6)),
+    offering: config?.offering ?? privateKeyToAccount(generatePrivateKey()).address,
+    assets: assetsScaled,
+    rate,
     maturity,
-    expiry,
-    start: expiry - 10,
+    expiry: config?.expiry ?? maturity - 1,
+    start: config?.start ?? maturity - 10,
     nonce: BigInt(Math.floor(Math.random() * 1e6)),
-    buy: Math.random() > 0.5,
-    chainId: 1n,
+    buy,
+    chainId: chain.id,
     loanToken,
-    collaterals: [
+    collaterals: config?.collaterals ?? [
       from2({
-        asset: zeroAddress,
+        asset: collateralAsset,
         oracle: zeroAddress,
         lltv
       })
     ],
-    callback: {
-      address: zeroAddress,
-      data: "0x",
-      gasLimit: 0n
-    },
-    consumed: 0n,
+    callback: config?.callback ?? callbackBySide,
+    consumed: consumed2,
     blockNumber: Math.floor(Math.random() * Number.MAX_SAFE_INTEGER)
   });
   return offer;
 }
+var weightedChoice = (pairs) => {
+  const total = pairs.reduce((sum, [, weight]) => sum + weight, 0);
+  let roll = Math.random() * total;
+  for (const [value, weight] of pairs) {
+    roll -= weight;
+    if (roll < 0) return value;
+  }
+  return pairs[0][0];
+};
 var domain = (chainId) => ({
   chainId,
   verifyingContract: zeroAddress
@@ -1460,7 +1438,7 @@ var OfferAbi = [
   },
   { name: "signature", type: "bytes" }
 ];
-function encode2(offer) {
+function encode(offer) {
   return encodeAbiParameters(OfferAbi, [
     offer.offering,
     offer.assets,
@@ -1477,7 +1455,7 @@ function encode2(offer) {
     offer.signature ?? "0x"
   ]);
 }
-function decode2(data, blockNumber) {
+function decode(data, blockNumber) {
   let decoded;
   try {
     decoded = decodeAbiParameters(OfferAbi, data);
@@ -1547,6 +1525,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 +1692,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,30 +1743,466 @@ 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/collectors/index.ts
-var collectors_exports = {};
-__export(collectors_exports, {
-  batch: () => batch2,
-  create: () => create2,
-  createBuilder: () => createBuilder,
-  fetchBalancesAndAllowances: () => fetchBalancesAndAllowances,
-  fetchCollateralAndDebt: () => fetchCollateralAndDebt,
-  fetchOraclePrices: () => fetchOraclePrices,
-  fetchUserVaultMarketLiquidity: () => fetchUserVaultMarketLiquidity,
-  morpho: () => morpho,
-  names: () => names,
-  run: () => run,
-  single: () => single,
-  start: () => start
+// 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/services/RouterAdmin.ts
-function create(parameters) {
-  const collector = "admin";
-  const {
-    client,
-    chain,
+// 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 = {};
+__export(collectors_exports, {
+  batch: () => batch2,
+  create: () => create2,
+  createBuilder: () => createBuilder,
+  fetchBalancesAndAllowances: () => fetchBalancesAndAllowances,
+  fetchCollateralAndDebt: () => fetchCollateralAndDebt,
+  fetchOraclePrices: () => fetchOraclePrices,
+  fetchUserVaultMarketLiquidity: () => fetchUserVaultMarketLiquidity,
+  morpho: () => morpho,
+  names: () => names,
+  run: () => run,
+  single: () => single,
+  start: () => start
+});
+
+// src/services/RouterAdmin.ts
+function create(parameters) {
+  const collector = "admin";
+  const {
+    client,
+    chain,
     withTransaction,
     options: { maxBatchSize = 25, maxBlockNumber } = {}
   } = parameters;
@@ -1991,20 +2461,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 +2505,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 +2647,7 @@ var ChainIdMismatchError = class extends BaseError {
 
 // src/mempool/MempoolClient.ts
 function connect(parameters) {
-  return from6(parameters);
+  return from7(parameters);
 }
 
 // src/stores/CollectorStore.ts
@@ -3952,385 +4433,150 @@ function handleAPIError(error2) {
         code: error2.code,
         message: error2.message,
         ...error2.details && typeof error2.details === "object" ? { details: error2.details } : {}
-      },
-      meta: {
-        timestamp: (/* @__PURE__ */ new Date()).toISOString()
-      }
-    }
-  };
-}
-var APIError = class extends Error {
-  constructor(statusCode, message, code, details) {
-    super(message);
-    this.statusCode = statusCode;
-    this.code = code;
-    this.details = details;
-    this.name = "APIError";
-  }
-};
-var ValidationError = class extends APIError {
-  constructor(message, details) {
-    super(400 /* BAD_REQUEST */, message, "VALIDATION_ERROR", details);
-  }
-};
-var InternalServerError = class extends APIError {
-  constructor(message = "Internal server error") {
-    super(500 /* INTERNAL_SERVER_ERROR */, message, "INTERNAL_SERVER_ERROR");
-  }
-};
-var BadRequestError = class extends APIError {
-  constructor(message = "Invalid JSON format", details) {
-    super(400 /* BAD_REQUEST */, message, "BAD_REQUEST", details);
-  }
-};
-function handleZodError(error2) {
-  const formattedErrors = error2.issues.map((err) => {
-    const field = err.path.join(".");
-    let issue = err.message;
-    if (err.code === "invalid_type") {
-      if (err.message.includes("received undefined")) {
-        issue = `${field} is required`;
-      } else {
-        issue = err.message;
-      }
-    } else if (err.code === "invalid_format" && err.format === "regex") {
-      issue = err.message;
-    } else if (err.code === "invalid_format") {
-      issue = `${field} has an invalid format`;
-    }
-    return {
-      field,
-      issue
-    };
-  });
-  return new ValidationError("Validation failed", formattedErrors);
-}
-
-// src/api/Api/Controllers/getHealth.ts
-async function getHealth(healthService) {
-  const logger = Logger_exports.getLogger();
-  try {
-    const status = await healthService.getStatus();
-    return success({ data: toSnakeCase({ status }) });
-  } catch (err) {
-    logger.error({
-      err,
-      msg: "Error getting health status",
-      errorMessage: err instanceof Error ? err.message : String(err),
-      errorStack: err instanceof Error ? err.stack : void 0
-    });
-    return error(err);
-  }
-}
-async function getHealthChains(healthService) {
-  const logger = Logger_exports.getLogger();
-  try {
-    const chains3 = await healthService.getChains();
-    return success({
-      data: chains3.map(
-        ({ chainId, blockNumber, updatedAt }) => toSnakeCase({
-          chainId,
-          blockNumber,
-          updatedAt
-        })
-      )
-    });
-  } catch (err) {
-    logger.error({
-      err,
-      msg: "Error getting health status for chains",
-      errorMessage: err instanceof Error ? err.message : String(err),
-      errorStack: err instanceof Error ? err.stack : void 0
-    });
-    return error(err);
-  }
-}
-async function getHealthCollectors(healthService) {
-  const logger = Logger_exports.getLogger();
-  try {
-    const collectors2 = await healthService.getCollectors();
-    return success({
-      data: collectors2.map(
-        ({ name, chainId, blockNumber, updatedAt, lag, status }) => toSnakeCase({
-          name,
-          chainId,
-          blockNumber,
-          updatedAt,
-          lag,
-          status
-        })
-      )
-    });
-  } catch (err) {
-    logger.error({
-      err,
-      msg: "Error getting health status for collectors",
-      errorMessage: err instanceof Error ? err.message : String(err),
-      errorStack: err instanceof Error ? err.stack : void 0
-    });
-    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
-var ObligationResponse_exports = {};
-__export(ObligationResponse_exports, {
-  from: () => from7
-});
-function from7(obligation) {
-  return toSnakeCase({ id: Obligation_exports.id(obligation), ...obligation });
-}
-
-// src/api/Api/Schema/OfferResponse.ts
-var OfferResponse_exports = {};
-__export(OfferResponse_exports, {
-  from: () => from8
-});
-function from8(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
-            }
-          }
-        }
+      },
+      meta: {
+        timestamp: (/* @__PURE__ */ new Date()).toISOString()
       }
     }
+  };
+}
+var APIError = class extends Error {
+  constructor(statusCode, message, code, details) {
+    super(message);
+    this.statusCode = statusCode;
+    this.code = code;
+    this.details = details;
+    this.name = "APIError";
   }
 };
-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"
+var ValidationError = class extends APIError {
+  constructor(message, details) {
+    super(400 /* BAD_REQUEST */, message, "VALIDATION_ERROR", details);
+  }
+};
+var InternalServerError = class extends APIError {
+  constructor(message = "Internal server error") {
+    super(500 /* INTERNAL_SERVER_ERROR */, message, "INTERNAL_SERVER_ERROR");
+  }
+};
+var BadRequestError = class extends APIError {
+  constructor(message = "Invalid JSON format", details) {
+    super(400 /* BAD_REQUEST */, message, "BAD_REQUEST", details);
+  }
+};
+function handleZodError(error2) {
+  const formattedErrors = error2.issues.map((err) => {
+    const field = err.path.join(".");
+    let issue = err.message;
+    if (err.code === "invalid_type") {
+      if (err.message.includes("received undefined")) {
+        issue = `${field} is required`;
+      } else {
+        issue = err.message;
+      }
+    } else if (err.code === "invalid_format" && err.format === "regex") {
+      issue = err.message;
+    } else if (err.code === "invalid_format") {
+      issue = `${field} has an invalid format`;
     }
-  ],
-  paths
+    return {
+      field,
+      issue
+    };
+  });
+  return new ValidationError("Validation failed", formattedErrors);
+}
+
+// src/api/Controllers/getHealth.ts
+async function getHealth(healthService) {
+  const logger = Logger_exports.getLogger();
+  try {
+    const status = await healthService.getStatus();
+    return success({ data: toSnakeCase({ status }) });
+  } catch (err) {
+    logger.error({
+      err,
+      msg: "Error getting health status",
+      errorMessage: err instanceof Error ? err.message : String(err),
+      errorStack: err instanceof Error ? err.stack : void 0
+    });
+    return error(err);
+  }
+}
+async function getHealthChains(healthService) {
+  const logger = Logger_exports.getLogger();
+  try {
+    const chains3 = await healthService.getChains();
+    return success({
+      data: chains3.map(
+        ({ chainId, blockNumber, updatedAt }) => toSnakeCase({
+          chainId,
+          blockNumber,
+          updatedAt
+        })
+      )
+    });
+  } catch (err) {
+    logger.error({
+      err,
+      msg: "Error getting health status for chains",
+      errorMessage: err instanceof Error ? err.message : String(err),
+      errorStack: err instanceof Error ? err.stack : void 0
+    });
+    return error(err);
+  }
+}
+async function getHealthCollectors(healthService) {
+  const logger = Logger_exports.getLogger();
+  try {
+    const collectors2 = await healthService.getCollectors();
+    return success({
+      data: collectors2.map(
+        ({ name, chainId, blockNumber, updatedAt, lag, status }) => toSnakeCase({
+          name,
+          chainId,
+          blockNumber,
+          updatedAt,
+          lag,
+          status
+        })
+      )
+    });
+  } catch (err) {
+    logger.error({
+      err,
+      msg: "Error getting health status for collectors",
+      errorMessage: err instanceof Error ? err.message : String(err),
+      errorStack: err instanceof Error ? err.stack : void 0
+    });
+    return error(err);
+  }
+}
+
+// src/api/Schema/ObligationResponse.ts
+var ObligationResponse_exports = {};
+__export(ObligationResponse_exports, {
+  from: () => from8
+});
+function from8(obligation, quote) {
+  return toSnakeCase({
+    id: quote.obligationId,
+    ...obligation,
+    ask: quote.ask,
+    bid: quote.bid
+  });
+}
+
+// src/api/Schema/OfferResponse.ts
+var OfferResponse_exports = {};
+__export(OfferResponse_exports, {
+  from: () => from9
 });
+function from9(offer) {
+  return toSnakeCase(offer);
+}
 
-// 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 +4587,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 +4614,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 +4642,7 @@ async function getOffers(queryParameters, store) {
   }
 }
 
-// src/api/Api/Api.ts
+// src/api/Api.ts
 function create5(config) {
   return {
     serve: ({ port }) => {
@@ -4416,6 +4674,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 +5301,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 +6100,7 @@ function create9(params) {
 }
 
 // src/services/Services.ts
-function from9(config) {
+function from10(config) {
   const {
     chain,
     rpcUrl,
@@ -5905,7 +6228,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: {
@@ -5919,6 +6242,7 @@ var RouterCmd = class _RouterCmd extends Command {
     command.setOptionValue("rpcUrl", rpcUrl);
     command.setOptionValue("routerServices", routerServices);
     command.setOptionValue("logger", logger);
+    command.setOptionValue("chain", chain);
     return { routerServices };
   }
   // allows to use the logger defined in the setup function for the action of the command
@@ -5933,12 +6257,116 @@ var RouterCmd = class _RouterCmd extends Command {
   }
 };
 
-// src/cli/commands/start.ts
+// src/cli/commands/mock.ts
+var mockCmd = new RouterCmd("mock");
+mockCmd.description("Start Router mock.").addOption(
+  new Option("--seed <n>", "Seed random offers to router").argParser((v) => Number(v)).default(0)
+).addOption(new Option("--file <path>", "Seed offers from a JSON file")).action(
+  async (opts) => {
+    const {
+      port,
+      routerServices: { liquidityStore, offerStore, routerApi },
+      logger,
+      chain
+    } = opts;
+    const stops = [];
+    if (opts.seed > 0) {
+      const offers2 = Array.from(Array(opts.seed ?? 0).keys()).map((_i) => ({
+        offer: Offer_exports.random({
+          chains: [chain],
+          loanTokens: Array.from(chain.whitelistedAssets.values()),
+          collateralTokens: Array.from(chain.whitelistedAssets.values()),
+          assetsDecimals: {
+            "0xA0b86991c6218b36c1d19D4a2e9Eb0cE3606eB48": 6,
+            // USDC
+            "0x6B175474E89094C44Da98b954EedeAC495271d0F": 18,
+            // DAI
+            "0xC02aaA39b223FE8D0A0e5C4F27eAD9083C756Cc2": 18,
+            // WETH
+            "0x2260FAC5E5542a773Aa44fBCfeDf7C193bc2C599": 8,
+            // WBTC
+            "0x4200000000000000000000000000000000000006": 18,
+            // WETH
+            "0x833589fCD6eDb6E08f4c7C32D4f71b54bdA02913": 6,
+            // USDC
+            "0x50c5725949A6F0c72E6C4a641F24049A917DB0Cb": 18
+            // DAI
+          }
+        }),
+        status: "valid"
+      }));
+      await offerStore.createMany(offers2);
+      for (const offer of offers2) {
+        await liquidityStore.save({
+          pools: [
+            {
+              id: offer.offer.hash,
+              amount: offer.offer.assets
+            }
+          ],
+          offerPools: [
+            {
+              offerHash: offer.offer.hash,
+              poolId: offer.offer.hash,
+              amount: offer.offer.assets
+            }
+          ],
+          links: []
+        });
+      }
+      logger.info({ msg: `Offers seeded`, count: opts.seed });
+    }
+    if (opts.file) {
+      const offers2 = await getOffersFromFile(opts.file);
+      await offerStore.createMany(offers2.map((ro) => ({ offer: ro })));
+      for (const offer of offers2) {
+        await liquidityStore.save({
+          pools: [
+            {
+              id: offer.hash,
+              amount: offer.assets
+            }
+          ],
+          offerPools: [
+            {
+              offerHash: offer.hash,
+              poolId: offer.hash,
+              amount: offer.assets
+            }
+          ],
+          links: []
+        });
+      }
+      logger.info({ msg: `Offers seeded from file`, count: offers2.length, file: opts.file });
+    }
+    await routerApi.serve({ port });
+    logger.info({ msg: `API started`, url: `http://localhost:${port}` });
+    const shutdown = async (signal) => {
+      logger.warn({ msg: `Shutdown signal`, signal });
+      try {
+        stops.forEach((stop) => stop());
+      } catch {
+      }
+      process.exit(0);
+    };
+    process.once("SIGINT", () => void shutdown("SIGINT"));
+    process.once("SIGTERM", () => void shutdown("SIGTERM"));
+    process.stdin.resume();
+  }
+);
+async function getOffersFromFile(file) {
+  const raw = await readFile(file, "utf8");
+  const json = JSON.parse(raw);
+  const items = Array.isArray(json) ? json : json.offers ?? [];
+  if (!Array.isArray(items) || items.length === 0) {
+    console.log("No offers found in file");
+    return [];
+  }
+  return items.map((o) => Offer_exports.from(o));
+}
 var startCmd = new RouterCmd("start");
 startCmd.description("Start Router services.").addOption(
   new Option("--block-window <n>", "Block window to get logs from").argParser((v) => Number(v)).default(100)
-).addOption(
-  new Option("--seed <n>", "Seed random offers to router").argParser((v) => Number(v)).default(0)
 ).addOption(new Option("--file <path>", "Seed offers from a JSON file")).addOption(
   new Option("--max-block-number <n>", "Block number at which to stop indexing").argParser(
     (v) => Number(v)
@@ -5951,24 +6379,10 @@ startCmd.description("Start Router services.").addOption(
   async (opts) => {
     const {
       port,
-      routerServices: { offerStore, indexer, routerApi },
+      routerServices: { indexer, routerApi },
       logger
     } = opts;
     const stops = [];
-    if (opts.seed > 0) {
-      await offerStore.createMany(
-        Array.from(Array(opts.seed ?? 0).keys()).map((_i) => ({
-          offer: Offer_exports.random(),
-          status: "valid"
-        }))
-      );
-      logger.info({ msg: `Offers seeded`, count: opts.seed });
-    }
-    if (opts.file) {
-      const offers2 = await getOffersFromFile(opts.file);
-      await offerStore.createMany(offers2.map((ro) => ({ offer: ro })));
-      logger.info({ msg: `Offers seeded from file`, count: offers2.length, file: opts.file });
-    }
     const selectedServices = new Set(opts.services);
     if (selectedServices.has("indexer")) {
       stops.push(await indexer.start());
@@ -5991,16 +6405,6 @@ startCmd.description("Start Router services.").addOption(
     process.stdin.resume();
   }
 );
-async function getOffersFromFile(file) {
-  const raw = await readFile(file, "utf8");
-  const json = JSON.parse(raw);
-  const items = Array.isArray(json) ? json : json.offers ?? [];
-  if (!Array.isArray(items) || items.length === 0) {
-    console.log("No offers found in file");
-    return [];
-  }
-  return items.map((o) => Offer_exports.from(o));
-}
 var tunnelCmd = new Command("tunnel");
 tunnelCmd.description("Expose the local Router via ngrok").addOption(
   new Option("--port <n>").env("ROUTER_PORT").default(7891).argParser((v) => Number(v))
@@ -6032,6 +6436,7 @@ cli.name(package_default.name.split("/")[1] || "cli").description(package_defaul
 cli.addCommand(startCmd);
 cli.addCommand(tunnelCmd);
 cli.addCommand(mempoolCmd);
+cli.addCommand(mockCmd);
 cli.command("__commands", { hidden: true }).description("internal: list commands").action(() => {
   const names2 = cli.commands.map((c) => c.name());
   console.log(JSON.stringify(names2));