@morpho-dev/router 0.1.16 → 0.1.18

package/dist/index.node.js

@@ -3,13 +3,15 @@
 var nodeServer = require('@hono/node-server');
 var hono = require('hono');
 var cors = require('hono/cors');
-var async_hooks = require('async_hooks');
+var v4 = require('zod/v4');
+var zodOpenapi = require('zod-openapi');
 var viem = require('viem');
 var actions = require('viem/actions');
 var chains$1 = require('viem/chains');
 var z6 = require('zod');
-var jsBase64 = require('js-base64');
 var accounts = require('viem/accounts');
+var jsBase64 = require('js-base64');
+var async_hooks = require('async_hooks');
 var drizzleOrm = require('drizzle-orm');
 var pgCore = require('drizzle-orm/pg-core');
 var path = require('path');
@@ -19,8 +21,6 @@ var migrator = require('drizzle-orm/node-postgres/migrator');
 var pglite$1 = require('drizzle-orm/pglite');
 var migrator$1 = require('drizzle-orm/pglite/migrator');
 var pg = require('pg');
-var v4 = require('zod/v4');
-var zodOpenapi = require('zod-openapi');
 
 function _interopDefault (e) { return e && e.__esModule ? e : { default: e }; }
 
@@ -51,9 +51,9 @@ var __export = (target, all) => {
     __defProp(target, name, { get: all[name], enumerable: true });
 };
 
-// src/api/Api/index.ts
-var Api_exports2 = {};
-__export(Api_exports2, {
+// src/api/RouterApi.ts
+var RouterApi_exports = {};
+__export(RouterApi_exports, {
   ChainHealth: () => ChainHealth,
   ChainsHealthResponse: () => ChainsHealthResponse,
   CollectorHealth: () => CollectorHealth,
@@ -68,1747 +68,1319 @@ __export(Api_exports2, {
   safeParse: () => safeParse
 });
 
-// src/api/Api/Controllers/index.ts
+// src/api/Controllers/index.ts
 var Controllers_exports = {};
 __export(Controllers_exports, {
+  getDocsHtml: () => getDocsHtml,
   getHealth: () => getHealth,
   getHealthChains: () => getHealthChains,
   getHealthCollectors: () => getHealthCollectors,
   getObligations: () => getObligations,
-  getOffers: () => getOffers
-});
-
-// src/services/Health.ts
-var Health_exports = {};
-__export(Health_exports, {
-  create: () => create9
-});
-
-// 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
+  getOffers: () => getOffers,
+  getSwaggerJson: () => getSwaggerJson
 });
 
-// src/services/Logger.ts
-var Logger_exports = {};
-__export(Logger_exports, {
-  LogLevelValues: () => LogLevelValues,
-  defaultLogger: () => defaultLogger,
-  getLogger: () => getLogger,
-  runWithLogger: () => runWithLogger,
-  silentLogger: () => silentLogger
+// src/core/Abi.ts
+var Abi_exports = {};
+__export(Abi_exports, {
+  ERC4626: () => ERC4626,
+  MetaMorpho: () => MetaMorpho,
+  MetaMorphoFactory: () => MetaMorphoFactory,
+  Morpho: () => Morpho,
+  Oracle: () => Oracle
 });
-var LogLevelValues = [
-  "trace",
-  "debug",
-  "info",
-  "warn",
-  "error",
-  "fatal",
-  "silent"
-];
-function defaultLogger(minLevel, pretty) {
-  const threshold = minLevel ?? process.env.ROUTER_LOG_LEVEL ?? "info";
-  const prettyEnabled = typeof pretty === "boolean" ? pretty : String(process.env.ROUTER_LOG_PRETTY ?? "false").toLowerCase() === "true";
-  const levelIndexByName = LogLevelValues.reduce(
-    (acc, lvl, idx) => {
-      acc[lvl] = idx;
-      return acc;
-    },
-    {}
-  );
-  const isEnabled = (methodLevel) => levelIndexByName[methodLevel] >= levelIndexByName[threshold];
-  const wrap = (consoleMethod, methodLevel) => isEnabled(methodLevel) ? (entry) => {
-    if (!prettyEnabled) {
-      console[consoleMethod](viem.stringify({ level: methodLevel, ...entry }));
-      return;
-    }
-    const { msg, ...rest } = entry;
-    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);
-  } : () => {
-  };
-  return {
-    trace: wrap("trace", "trace"),
-    debug: wrap("debug", "debug"),
-    info: wrap("info", "info"),
-    warn: wrap("warn", "warn"),
-    error: wrap("error", "error"),
-    fatal: wrap("error", "fatal")
-  };
-}
-function silentLogger() {
-  const noop = () => {
-  };
-  return { trace: noop, debug: noop, info: noop, warn: noop, error: noop, fatal: noop };
-}
-var loggerContext = new async_hooks.AsyncLocalStorage();
-function runWithLogger(logger, fn) {
-  return loggerContext.run(logger, fn);
-}
-function getLogger() {
-  return loggerContext.getStore() ?? defaultLogger();
-}
-function formatValue(value) {
-  if (value === null || value === void 0 || typeof value === "number" || typeof value === "bigint" || typeof value === "boolean") {
-    return String(value);
-  }
-  if (typeof value === "string") {
-    if (value.includes(" ")) return JSON.stringify(value);
-    return value;
-  }
-  try {
-    return viem.stringify(value);
-  } catch {
-    try {
-      return JSON.stringify(value);
-    } catch {
-      return String(value);
-    }
+var Oracle = [
+  {
+    type: "function",
+    name: "price",
+    inputs: [],
+    outputs: [{ name: "", type: "uint256" }],
+    stateMutability: "view"
   }
-}
-
-// src/utils/index.ts
-var utils_exports = {};
-__export(utils_exports, {
-  BaseError: () => BaseError,
-  Time: () => time_exports,
-  batch: () => batch,
-  batchMulticall: () => batchMulticall,
-  fromSnakeCase: () => fromSnakeCase,
-  lazy: () => lazy,
-  max: () => max,
-  min: () => min,
-  poll: () => poll,
-  retry: () => retry,
-  toSnakeCase: () => toSnakeCase,
-  wait: () => wait
-});
-
-// src/utils/BigMath.ts
-function max(a, b) {
-  return a > b ? a : b;
-}
-function min(a, b) {
-  return a < b ? a : b;
-}
-
-// src/utils/batch.ts
-function* batch(array2, batchSize) {
-  for (let i = 0; i < array2.length; i += batchSize) {
-    yield array2.slice(i, i + batchSize);
+];
+var ERC4626 = [
+  {
+    type: "function",
+    name: "asset",
+    inputs: [],
+    outputs: [{ name: "", type: "address" }],
+    stateMutability: "view"
   }
-}
-
-// src/utils/retry.ts
-var retry = async (fn, attempts = 3, delayMs = 50) => {
-  let lastErr;
-  for (let i = 0; i < attempts; i++) {
-    try {
-      return await fn();
-    } catch (err) {
-      lastErr = err;
-      if (i < attempts - 1) await new Promise((r) => setTimeout(r, delayMs));
-    }
+];
+var MetaMorphoFactory = [
+  {
+    type: "function",
+    name: "isMetaMorpho",
+    inputs: [{ name: "target", type: "address" }],
+    outputs: [{ name: "", type: "bool" }],
+    stateMutability: "view"
   }
-  throw lastErr;
-};
-
-// src/utils/batchMulticall.ts
-async function batchMulticall(parameters) {
-  const { client, calls, batchSize, retryAttempts, retryDelayMs, blockNumber } = parameters;
-  const results = [];
-  for (const callsBatch of batch(calls, batchSize)) {
-    const batchResults = await retry(
-      () => client.multicall({
-        allowFailure: false,
-        contracts: callsBatch,
-        ...blockNumber ? { blockNumber } : {}
-      }),
-      retryAttempts,
-      retryDelayMs
-    );
-    results.push(...batchResults);
+];
+var MetaMorpho = [
+  {
+    type: "function",
+    name: "withdrawQueue",
+    inputs: [{ name: "index", type: "uint256" }],
+    outputs: [{ name: "", type: "bytes32" }],
+    stateMutability: "view"
+  },
+  {
+    type: "function",
+    name: "withdrawQueueLength",
+    inputs: [],
+    outputs: [{ name: "", type: "uint256" }],
+    stateMutability: "view"
+  },
+  {
+    type: "function",
+    name: "maxWithdraw",
+    inputs: [{ name: "owner", type: "address" }],
+    outputs: [{ name: "", type: "uint256" }],
+    stateMutability: "view"
   }
-  return results;
-}
-
-// src/utils/Errors.ts
-var Errors_exports = {};
-__export(Errors_exports, {
-  BaseError: () => BaseError
-});
-var BaseError = class _BaseError extends Error {
-  details;
-  shortMessage;
-  cause;
-  name = "BaseError";
-  constructor(shortMessage, options = {}) {
-    const details = (() => {
-      if (options.cause instanceof _BaseError) {
-        if (options.cause.details) return options.cause.details;
-        if (options.cause.shortMessage) return options.cause.shortMessage;
-      }
-      if (options.cause && "details" in options.cause && typeof options.cause.details === "string")
-        return options.cause.details;
-      if (options.cause?.message) return options.cause.message;
-      return options.details;
-    })();
-    const message = [
-      shortMessage || "An error occurred.",
-      ...options.metaMessages ? ["", ...options.metaMessages] : [],
-      ...details ? ["", details ? `Details: ${details}` : void 0] : []
-    ].filter((x) => typeof x === "string").join("\n");
-    super(message, options.cause ? { cause: options.cause } : void 0);
-    this.cause = options.cause;
-    this.details = details;
-    this.shortMessage = shortMessage;
-  }
-  walk(fn) {
-    return walk(this, fn);
+];
+var Morpho = [
+  {
+    type: "function",
+    name: "collateralOf",
+    inputs: [
+      {
+        name: "",
+        type: "address",
+        internalType: "address"
+      },
+      {
+        name: "",
+        type: "bytes32",
+        internalType: "bytes32"
+      },
+      {
+        name: "",
+        type: "address",
+        internalType: "address"
+      }
+    ],
+    outputs: [
+      {
+        name: "",
+        type: "uint256",
+        internalType: "uint256"
+      }
+    ],
+    stateMutability: "view"
+  },
+  {
+    type: "function",
+    name: "debtOf",
+    inputs: [
+      {
+        name: "",
+        type: "address",
+        internalType: "address"
+      },
+      {
+        name: "",
+        type: "bytes32",
+        internalType: "bytes32"
+      }
+    ],
+    outputs: [
+      {
+        name: "",
+        type: "uint256",
+        internalType: "uint256"
+      }
+    ],
+    stateMutability: "view"
+  },
+  {
+    type: "function",
+    name: "market",
+    inputs: [
+      {
+        name: "id",
+        type: "bytes32",
+        internalType: "Id"
+      }
+    ],
+    outputs: [
+      {
+        name: "totalSupplyAssets",
+        type: "uint128",
+        internalType: "uint128"
+      },
+      {
+        name: "totalSupplyShares",
+        type: "uint128",
+        internalType: "uint128"
+      },
+      {
+        name: "totalBorrowAssets",
+        type: "uint128",
+        internalType: "uint128"
+      },
+      {
+        name: "totalBorrowShares",
+        type: "uint128",
+        internalType: "uint128"
+      },
+      {
+        name: "lastUpdate",
+        type: "uint128",
+        internalType: "uint128"
+      },
+      {
+        name: "fee",
+        type: "uint128",
+        internalType: "uint128"
+      }
+    ],
+    stateMutability: "view"
+  },
+  {
+    type: "function",
+    name: "position",
+    inputs: [
+      {
+        name: "id",
+        type: "bytes32",
+        internalType: "Id"
+      },
+      {
+        name: "user",
+        type: "address",
+        internalType: "address"
+      }
+    ],
+    outputs: [
+      {
+        name: "supplyShares",
+        type: "uint256",
+        internalType: "uint256"
+      },
+      {
+        name: "borrowShares",
+        type: "uint128",
+        internalType: "uint128"
+      },
+      {
+        name: "collateral",
+        type: "uint128",
+        internalType: "uint128"
+      }
+    ],
+    stateMutability: "view"
   }
-};
-function walk(err, fn) {
-  if (fn?.(err)) return err;
-  if (err && typeof err === "object" && "cause" in err && err.cause) return walk(err.cause, fn);
-  return fn ? null : err;
-}
+];
 
-// src/utils/Format.ts
-var Format_exports = {};
-__export(Format_exports, {
-  fromSnakeCase: () => fromSnakeCase,
-  toSnakeCase: () => toSnakeCase
+// src/core/Callback.ts
+var Callback_exports = {};
+__export(Callback_exports, {
+  CallbackType: () => CallbackType,
+  WhitelistedCallbackAddresses: () => WhitelistedCallbackAddresses,
+  decodeBuyVaultV1Callback: () => decodeBuyVaultV1Callback,
+  decodeSellERC20Callback: () => decodeSellERC20Callback,
+  encodeBuyVaultV1Callback: () => encodeBuyVaultV1Callback,
+  encodeSellERC20Callback: () => encodeSellERC20Callback
 });
-function toSnakeCase(obj) {
-  return stringifyBigint(
-    processObject(
-      obj,
-      (s2) => s2.replace(/[A-Z]/g, (c) => `_${c.toLowerCase()}`),
-      (value) => typeof value === "string" && viem.isAddress(value.toLowerCase()) ? viem.getAddress(value.toLowerCase()) : value
-    )
-  );
+var CallbackType = /* @__PURE__ */ ((CallbackType2) => {
+  CallbackType2["BuyWithEmptyCallback"] = "buy_with_empty_callback";
+  CallbackType2["BuyVaultV1Callback"] = "buy_vault_v1_callback";
+  CallbackType2["SellERC20Callback"] = "sell_erc20_callback";
+  return CallbackType2;
+})(CallbackType || {});
+var WhitelistedCallbackAddresses = {
+  ["buy_with_empty_callback" /* BuyWithEmptyCallback */]: [],
+  ["buy_vault_v1_callback" /* BuyVaultV1Callback */]: [
+    "0x3333333333333333333333333333333333333333",
+    "0x4444444444444444444444444444444444444444"
+    // @TODO: update once deployed and add mapping per chain if needed
+  ].map((address) => address.toLowerCase()),
+  ["sell_erc20_callback" /* SellERC20Callback */]: [
+    "0x1111111111111111111111111111111111111111",
+    "0x2222222222222222222222222222222222222222"
+    // @TODO: update once deployed and add mapping per chain if needed
+  ].map((address) => address.toLowerCase())
+};
+function decodeBuyVaultV1Callback(data) {
+  if (!data || data === "0x") throw new Error("Empty callback data");
+  try {
+    const [vaults, amounts] = viem.decodeAbiParameters(
+      [{ type: "address[]" }, { type: "uint256[]" }],
+      data
+    );
+    if (vaults.length !== amounts.length) {
+      throw new Error("Mismatched array lengths");
+    }
+    return vaults.map((v, i) => ({ vault: v, amount: amounts[i] }));
+  } catch (_) {
+    throw new Error("Invalid BuyVaultV1Callback callback data");
+  }
 }
-function fromSnakeCase(obj) {
-  return processObject(
-    obj,
-    (s2) => viem.isAddress(s2.toLowerCase()) ? s2 : s2.replace(/_([a-z])/g, (_, c) => c.toUpperCase()),
-    (value) => typeof value === "string" && viem.isAddress(value.toLowerCase()) ? value.toLowerCase() : value
-  );
+function decodeSellERC20Callback(data) {
+  if (!data || data === "0x") throw new Error("Empty callback data");
+  try {
+    const [collaterals, amounts] = viem.decodeAbiParameters(
+      [{ type: "address[]" }, { type: "uint256[]" }],
+      data
+    );
+    if (collaterals.length !== amounts.length) {
+      throw new Error("Mismatched array lengths");
+    }
+    return collaterals.map((c, i) => ({ collateral: c, amount: amounts[i] }));
+  } catch (_) {
+    throw new Error("Invalid SellERC20Callback callback data");
+  }
 }
-function processObject(obj, fnKey, fnValue) {
-  if (typeof obj !== "object" || obj === null) return obj;
-  if (Array.isArray(obj)) return obj.map((item) => processObject(item, fnKey, fnValue));
-  return Object.entries(obj).reduce(
-    (acc, [key, value]) => {
-      const newKey = fnKey(key);
-      acc[newKey] = typeof value === "object" && value !== null ? processObject(value, fnKey, fnValue) : fnValue(value);
-      return acc;
-    },
-    {}
+function encodeBuyVaultV1Callback(parameters) {
+  return viem.encodeAbiParameters(
+    [{ type: "address[]" }, { type: "uint256[]" }],
+    [parameters.vaults, parameters.amounts]
   );
 }
-function stringifyBigint(value) {
-  if (typeof value === "bigint") return value.toString();
-  if (Array.isArray(value)) return value.map(stringifyBigint);
-  if (value && typeof value === "object") {
-    const out = {};
-    for (const [k, v] of Object.entries(value)) {
-      out[k] = stringifyBigint(v);
-    }
-    return out;
-  }
-  return value;
+function encodeSellERC20Callback(parameters) {
+  return viem.encodeAbiParameters(
+    [{ type: "address[]" }, { type: "uint256[]" }],
+    [parameters.collaterals, parameters.amounts]
+  );
 }
 
-// src/utils/lazy.ts
-function lazy(pollFn) {
-  return () => async function* () {
-    let active = true;
-    let resolveNext = null;
-    const queue = [];
-    const wait2 = () => new Promise((resolve) => {
-      resolveNext = resolve;
-    });
-    const emit = (item) => {
-      queue.push(item);
-      resolveNext?.();
-      resolveNext = null;
-    };
-    let unpoll = null;
-    const stop = () => {
-      active = false;
-      unpoll?.();
-      resolveNext?.();
-      resolveNext = null;
-    };
-    unpoll = pollFn(emit, { stop });
-    try {
-      while (active) {
-        if (queue.length === 0) await wait2();
-        while (queue.length > 0 && active) yield queue.shift();
-      }
-    } finally {
-      stop();
-    }
-  }();
-}
+// src/core/Chain.ts
+var Chain_exports = {};
+__export(Chain_exports, {
+  ChainId: () => ChainId,
+  InvalidBatchSizeError: () => InvalidBatchSizeError,
+  InvalidBlockRangeError: () => InvalidBlockRangeError,
+  InvalidBlockWindowError: () => InvalidBlockWindowError,
+  MissingBlockNumberError: () => MissingBlockNumberError,
+  chainIds: () => chainIds,
+  chainNames: () => chainNames,
+  chains: () => chains,
+  getChain: () => getChain,
+  getWhitelistedChains: () => getWhitelistedChains,
+  streamLogs: () => streamLogs
+});
 
-// src/utils/wait.ts
-async function wait(time) {
-  return new Promise((res) => setTimeout(res, time));
+// src/utils/BigMath.ts
+function max(a, b) {
+  return a > b ? a : b;
+}
+function min(a, b) {
+  return a < b ? a : b;
 }
 
-// src/utils/poll.ts
-function poll(fn, { interval }) {
-  let active = true;
-  const unwatch = () => active = false;
-  const watch2 = async () => {
-    await wait(interval);
-    const poll2 = async () => {
-      if (!active) return;
-      await fn({ unpoll: unwatch });
-      await wait(interval);
-      poll2();
-    };
-    poll2();
-  };
-  watch2();
-  return unwatch;
+// src/utils/batch.ts
+function* batch(array2, batchSize) {
+  for (let i = 0; i < array2.length; i += batchSize) {
+    yield array2.slice(i, i + batchSize);
+  }
 }
 
-// src/utils/time.ts
-var time_exports = {};
-__export(time_exports, {
-  max: () => max2,
-  now: () => now
+// src/utils/Errors.ts
+var Errors_exports = {};
+__export(Errors_exports, {
+  BaseError: () => BaseError
 });
-function now() {
-  return Math.floor(Date.now() / 1e3);
-}
-function max2() {
-  return 864e16;
+var BaseError = class _BaseError extends Error {
+  details;
+  shortMessage;
+  cause;
+  name = "BaseError";
+  constructor(shortMessage, options = {}) {
+    const details = (() => {
+      if (options.cause instanceof _BaseError) {
+        if (options.cause.details) return options.cause.details;
+        if (options.cause.shortMessage) return options.cause.shortMessage;
+      }
+      if (options.cause && "details" in options.cause && typeof options.cause.details === "string")
+        return options.cause.details;
+      if (options.cause?.message) return options.cause.message;
+      return options.details;
+    })();
+    const message = [
+      shortMessage || "An error occurred.",
+      ...options.metaMessages ? ["", ...options.metaMessages] : [],
+      ...details ? ["", details ? `Details: ${details}` : void 0] : []
+    ].filter((x) => typeof x === "string").join("\n");
+    super(message, options.cause ? { cause: options.cause } : void 0);
+    this.cause = options.cause;
+    this.details = details;
+    this.shortMessage = shortMessage;
+  }
+  walk(fn) {
+    return walk(this, fn);
+  }
+};
+function walk(err, fn) {
+  if (fn?.(err)) return err;
+  if (err && typeof err === "object" && "cause" in err && err.cause) return walk(err.cause, fn);
+  return fn ? null : err;
 }
 
-// src/services/RouterAdmin.ts
-function create(parameters) {
-  const collector = "admin";
+// src/core/Chain.ts
+var chainNames = ["ethereum", "base", "ethereum-virtual-testnet", "anvil"];
+var ChainId = {
+  ETHEREUM: BigInt(chains$1.mainnet.id),
+  BASE: BigInt(chains$1.base.id),
+  "ETHEREUM-VIRTUAL-TESTNET": 109111114n,
+  ANVIL: 505050505n
+  // random id to not clash with other chains
+};
+var chainIds = new Set(Object.values(ChainId));
+var chainNameLookup = new Map(Object.entries(ChainId).map(([key, value]) => [value, key]));
+function getChain(chainId) {
+  const chainName = chainNameLookup.get(chainId)?.toLowerCase();
+  if (!chainName) {
+    return void 0;
+  }
+  return chains[chainName];
+}
+var getWhitelistedChains = () => {
+  return [chains.ethereum, chains.base, chains["ethereum-virtual-testnet"], chains.anvil];
+};
+var chains = {
+  ethereum: {
+    ...chains$1.mainnet,
+    id: ChainId.ETHEREUM,
+    name: "ethereum",
+    whitelistedAssets: new Set(
+      [
+        "0xA0b86991c6218b36c1d19D4a2e9Eb0cE3606eB48",
+        // USDC
+        "0x6B175474E89094C44Da98b954EedeAC495271d0F",
+        // DAI
+        "0xC02aaA39b223FE8D0A0e5C4F27eAD9083C756Cc2",
+        // WETH
+        "0x2260FAC5E5542a773Aa44fBCfeDf7C193bc2C599"
+        // WBTC
+      ].map((address) => address.toLowerCase())
+    ),
+    morpho: "0x0000000000000000000000000000000000000000",
+    morphoBlue: "0xBBBBBbbBBb9cC5e90e3b3Af64bdAF62C37EEFFCb",
+    mempool: {
+      address: "0x0000000000000000000000000000000000000000",
+      deploymentBlock: 23347674,
+      reindexBuffer: 10
+    },
+    vaultV1Factory: {
+      "v1.0": "0xA9c3D3a366466Fa809d1Ae982Fb2c46E5fC41101",
+      "v1.1": "0x1897A8997241C1cD4bD0698647e4EB7213535c24"
+    }
+  },
+  base: {
+    ...chains$1.base,
+    id: ChainId.BASE,
+    name: "base",
+    whitelistedAssets: new Set(
+      [
+        "0x833589fCD6eDb6E08f4c7C32D4f71b54bdA02913",
+        // USDC
+        "0x50c5725949A6F0c72E6C4a641F24049A917DB0Cb",
+        // DAI
+        "0x4200000000000000000000000000000000000006",
+        // WETH
+        "0x2260FAC5E5542a773Aa44fBCfeDf7C193bc2C599"
+        // WBTC
+      ].map((address) => address.toLowerCase())
+    ),
+    morpho: "0x0000000000000000000000000000000000000000",
+    morphoBlue: "0xBBBBBbbBBb9cC5e90e3b3Af64bdAF62C37EEFFCb",
+    mempool: {
+      address: "0x0000000000000000000000000000000000000000",
+      deploymentBlock: 35449942,
+      reindexBuffer: 10
+    },
+    vaultV1Factory: {
+      "v1.0": "0xA9c3D3a366466Fa809d1Ae982Fb2c46E5fC41101",
+      "v1.1": "0xFf62A7c278C62eD665133147129245053Bbf5918"
+    }
+  },
+  "ethereum-virtual-testnet": {
+    ...chains$1.mainnet,
+    id: ChainId["ETHEREUM-VIRTUAL-TESTNET"],
+    name: "ethereum-virtual-testnet",
+    whitelistedAssets: new Set(
+      [
+        "0xA0b86991c6218b36c1d19D4a2e9Eb0cE3606eB48",
+        // USDC
+        "0x6B175474E89094C44Da98b954EedeAC495271d0F",
+        // DAI
+        "0xC02aaA39b223FE8D0A0e5C4F27eAD9083C756Cc2",
+        // WETH
+        "0x2260FAC5E5542a773Aa44fBCfeDf7C193bc2C599"
+        // WBTC
+      ].map((address) => address.toLowerCase())
+    ),
+    morpho: "0x11a002d45db720ed47a80d2f3489cba5b833eaf5",
+    // @TODO: This is mock Consumed contract, update with Terms once stable
+    morphoBlue: "0xBBBBBbbBBb9cC5e90e3b3Af64bdAF62C37EEFFCb",
+    mempool: {
+      address: "0x5b06224f736a57635b5bcb50b8ef178b189107cb",
+      deploymentBlock: 23224302,
+      reindexBuffer: 10
+    },
+    vaultV1Factory: {
+      "v1.0": "0xA9c3D3a366466Fa809d1Ae982Fb2c46E5fC41101",
+      "v1.1": "0x1897A8997241C1cD4bD0698647e4EB7213535c24"
+    }
+  },
+  anvil: {
+    ...chains$1.anvil,
+    id: ChainId.ANVIL,
+    name: "anvil",
+    whitelistedAssets: new Set(
+      [
+        "0xA0b86991c6218b36c1d19D4a2e9Eb0cE3606eB48",
+        // USDC
+        "0x6B175474E89094C44Da98b954EedeAC495271d0F",
+        // DAI
+        "0xC02aaA39b223FE8D0A0e5C4F27eAD9083C756Cc2",
+        // WETH
+        "0x2260FAC5E5542a773Aa44fBCfeDf7C193bc2C599"
+        // WBTC
+      ].map((address) => address.toLowerCase())
+    ),
+    morpho: "0x23DFBc4B8B80C14CC5e25011B8491f268395BAd6",
+    morphoBlue: "0x0000000000000000000000000000000000000000",
+    // Set dynamically in tests
+    mempool: {
+      address: "0xD946246695A9259F3B33a78629026F61B3Ab40aF",
+      deploymentBlock: 23223727,
+      reindexBuffer: 10
+    },
+    vaultV1Factory: {
+      "v1.0": "0x0000000000000000000000000000000000000000",
+      "v1.1": "0x0000000000000000000000000000000000000000"
+    }
+  }
+};
+var MAX_BATCH_SIZE = 1e4;
+var DEFAULT_BATCH_SIZE = 2500;
+var MAX_BLOCK_WINDOW = 2e3;
+var DEFAULT_BLOCK_WINDOW = 500;
+async function* streamLogs(parameters) {
   const {
     client,
-    chain,
-    withTransaction,
-    options: { maxBatchSize = 25, maxBlockNumber } = {}
+    contractAddress,
+    event,
+    blockNumberGte,
+    blockNumberLte,
+    order = "desc",
+    options: { maxBatchSize = DEFAULT_BATCH_SIZE, blockWindow = DEFAULT_BLOCK_WINDOW } = {}
   } = parameters;
-  const maxBlockNumberBI = maxBlockNumber !== void 0 ? BigInt(maxBlockNumber) : void 0;
-  let finalizedBlock = null;
-  let unfinalizedBlocks = [];
-  const logger = getLogger();
-  let isMaxBlockNumberReached = false;
-  let tick = 0;
-  return {
-    syncBlock: async () => {
-      if (isMaxBlockNumberReached) return;
-      const head = await client.getBlock({
-        blockTag: "latest",
-        includeTransactions: false
-      });
-      await withTransaction(async ({ chainStore, collectorStore }) => {
-        const { epoch, blockNumber: latestSavedBlockNumber } = await chainStore.getBlockNumber(
-          chain.id
-        );
-        if (maxBlockNumberBI !== void 0 && head.number >= maxBlockNumberBI) {
-          logger.info({
-            msg: `Head is greater than max block number`,
-            collector,
-            chainId: chain.id,
-            block_number: head.number,
-            max_block_number: maxBlockNumber
-          });
-          isMaxBlockNumberReached = true;
-          await chainStore.saveBlockNumber({
-            chainId: chain.id,
-            blockNumber: maxBlockNumber,
-            epoch: epoch + 1n
-          });
-          await Promise.all(
-            names.map(
-              async (collectorName) => collectorStore.saveBlockNumber({
-                collectorName,
-                chainId: chain.id,
-                blockNumber: maxBlockNumber,
-                epoch: epoch + 1n
-              })
-            )
-          );
-          return;
-        }
-        finalizedBlock = await fetchFinalizedBlock({
-          tick,
-          client,
-          chain,
-          logger,
-          collector,
-          unfinalizedBlocks,
-          previousFinalizedBlock: finalizedBlock
-        });
-        tick++;
-        let {
-          block: returnedBlock,
-          didReorgHappened,
-          unfinalizedBlocks: newUnfinalizedBlocks
-        } = await reconcile({
-          client,
-          block: head,
-          unfinalizedBlocks,
-          finalizedBlock,
-          logger,
-          collector,
-          chain,
-          maxBatchSize
-        });
-        unfinalizedBlocks = newUnfinalizedBlocks;
-        const blockNumber = Number(returnedBlock.number);
-        didReorgHappened = didReorgHappened || blockNumber < latestSavedBlockNumber;
-        await chainStore.saveBlockNumber({
-          chainId: chain.id,
-          blockNumber,
-          epoch: didReorgHappened ? epoch + 1n : epoch
-        });
-        if (didReorgHappened) {
-          await Promise.all(
-            names.map(
-              async (collectorName) => collectorStore.saveBlockNumber({
-                collectorName,
-                chainId: chain.id,
-                blockNumber,
-                epoch: epoch + 1n
-              })
-            )
-          );
-        }
-      });
-    }
-  };
-}
-var commonAncestor = (block, unfinalizedBlocks) => {
-  const parent = unfinalizedBlocks.find((b) => b.hash === block.parentHash);
-  if (parent) return parent;
-  return null;
-};
-var fetchFinalizedBlock = async (parameters) => {
-  let { tick, client, chain, logger, collector, unfinalizedBlocks, previousFinalizedBlock } = parameters;
-  let finalizedBlock = previousFinalizedBlock;
-  if (tick % 20 === 0 || previousFinalizedBlock === null) {
-    finalizedBlock = await client.getBlock({
-      blockTag: "finalized",
-      includeTransactions: false
+  if (maxBatchSize > MAX_BATCH_SIZE) throw new InvalidBatchSizeError(maxBatchSize);
+  if (blockWindow > MAX_BLOCK_WINDOW) throw new InvalidBlockWindowError(blockWindow);
+  if (order === "asc" && blockNumberGte === void 0) throw new MissingBlockNumberError();
+  const latestBlock = (await actions.getBlock(client, { blockTag: "latest", includeTransactions: false })).number;
+  let toBlock = 0n;
+  if (order === "asc")
+    toBlock = min(BigInt(blockNumberGte) + BigInt(blockWindow), latestBlock);
+  if (order === "desc")
+    toBlock = blockNumberLte === void 0 ? latestBlock : min(BigInt(blockNumberLte), latestBlock);
+  let fromBlock = 0n;
+  if (order === "asc") fromBlock = min(BigInt(blockNumberGte), latestBlock);
+  if (order === "desc")
+    fromBlock = max(BigInt(blockNumberGte || toBlock - BigInt(blockWindow)), 0n);
+  if (order === "asc") toBlock = min(toBlock, fromBlock + BigInt(blockWindow));
+  if (order === "desc") fromBlock = max(fromBlock, toBlock - BigInt(blockWindow));
+  if (fromBlock > toBlock) throw new InvalidBlockRangeError(fromBlock, toBlock);
+  let streaming = true;
+  while (streaming) {
+    const logs = await actions.getLogs(client, {
+      address: contractAddress,
+      event,
+      fromBlock,
+      toBlock
     });
-    if (finalizedBlock === null || finalizedBlock.number === null) {
-      const msg = "Failed to get finalized block";
-      logger.fatal({ collector, chainId: chain.id, msg });
-      throw new Error(msg);
+    logs.sort((a, b) => {
+      if (a.blockNumber !== b.blockNumber)
+        return order === "asc" ? Number(a.blockNumber - b.blockNumber) : Number(b.blockNumber - a.blockNumber);
+      if (a.transactionIndex !== b.transactionIndex)
+        return order === "asc" ? a.transactionIndex - b.transactionIndex : b.transactionIndex - a.transactionIndex;
+      return order === "asc" ? a.logIndex - b.logIndex : b.logIndex - a.logIndex;
+    });
+    for (const logBatch of batch(logs, maxBatchSize)) {
+      if (logBatch.length === 0) break;
+      yield {
+        logs: logBatch,
+        blockNumber: logBatch.length === maxBatchSize ? (
+          // if the batch is full, return the last block number, block numbers are always sorted
+          Number(logBatch[logBatch.length - 1]?.blockNumber)
+        ) : (
+          // if the batch is not full, return `toBlock` or `fromBlock` to indicate until which block the logs were fetched
+          order === "asc" ? Number(toBlock) : Number(fromBlock)
+        )
+      };
+    }
+    streaming = order === "asc" ? toBlock < (blockNumberLte || latestBlock) : fromBlock > (blockNumberGte || 0n);
+    if (order === "asc") {
+      fromBlock = min(BigInt(toBlock) + 1n, latestBlock);
+      toBlock = min(fromBlock + BigInt(blockWindow), latestBlock);
+    }
+    if (order === "desc") {
+      const lowerBound = BigInt(blockNumberGte || 0);
+      const windowSize = BigInt(blockWindow);
+      const nextToBlock = max(fromBlock - 1n, lowerBound);
+      const nextFromBlock = max(nextToBlock - windowSize, lowerBound);
+      toBlock = nextToBlock;
+      fromBlock = nextFromBlock;
     }
-    unfinalizedBlocks = unfinalizedBlocks.filter((b) => b.number >= finalizedBlock.number);
   }
-  if (finalizedBlock.number === null || finalizedBlock.hash === null || finalizedBlock.parentHash === null) {
-    const msg = "Failed to get finalized block";
-    logger.fatal({ collector, chainId: chain.id, msg });
-    throw new Error(msg);
+  yield { logs: [], blockNumber: order === "asc" ? Number(toBlock) : Number(fromBlock) };
+  return;
+}
+var InvalidBlockRangeError = class extends BaseError {
+  name = "Chain.InvalidBlockRangeError";
+  constructor(fromBlock, toBlock) {
+    super(
+      `Invalid block range while streaming data from chain. From block ${fromBlock} to block ${toBlock}.`
+    );
   }
-  return {
-    hash: finalizedBlock.hash,
-    number: finalizedBlock.number,
-    parentHash: finalizedBlock.parentHash
-  };
 };
-var reconcile = async (parameters) => {
-  let { client, block, unfinalizedBlocks, finalizedBlock, logger, collector, chain, maxBatchSize } = parameters;
-  if (block.hash === null || block.number === null || block.parentHash === null)
-    throw new Error("Failed to get block");
-  const latestBlock = unfinalizedBlocks[unfinalizedBlocks.length - 1];
-  if (latestBlock === void 0) {
-    const newBlock2 = {
-      hash: block.hash,
-      number: block.number,
-      parentHash: block.parentHash
-    };
-    unfinalizedBlocks.push(newBlock2);
-    return { block: newBlock2, didReorgHappened: false, unfinalizedBlocks };
-  }
-  if (latestBlock.hash === block.hash)
-    return { block: latestBlock, didReorgHappened: false, unfinalizedBlocks };
-  if (latestBlock.number >= block.number) {
-    const ancestor = commonAncestor(block, unfinalizedBlocks) || finalizedBlock;
-    logger.info({
-      msg: `Reorg detected`,
-      collector,
-      chain_id: chain.id,
-      ancestor: ancestor.number,
-      block_range: [latestBlock.number, block.number]
-    });
-    unfinalizedBlocks = unfinalizedBlocks.filter((b) => b.number <= ancestor.number);
-    return { block: ancestor, didReorgHappened: true, unfinalizedBlocks };
-  }
-  if (latestBlock.number + 1n < block.number) {
-    logger.debug({
-      collector,
-      chain_id: chain.id,
-      block_range: [latestBlock.number, block.number],
-      msg: `Missing blocks`
-    });
-    const missingBlockNumbers = (() => {
-      const missingBlockNumbers2 = [];
-      let start2 = latestBlock.number + 1n;
-      const threshold = latestBlock.number + BigInt(maxBatchSize) > block.number ? block.number : latestBlock.number + BigInt(maxBatchSize);
-      while (start2 < threshold) {
-        missingBlockNumbers2.push(start2);
-        start2 = start2 + 1n;
-      }
-      return missingBlockNumbers2;
-    })();
-    const missingBlocks = await Promise.all(
-      missingBlockNumbers.map(
-        (blockNumber) => retry(async () => await client.getBlock({ blockNumber, includeTransactions: false }))
-      )
+var InvalidBlockWindowError = class extends BaseError {
+  name = "Chain.InvalidBlockWindowError";
+  constructor(blockWindow) {
+    super(
+      `Invalid block window while streaming data from chain. Maximum is ${MAX_BLOCK_WINDOW}. Got ${blockWindow}.`
     );
-    for (const missingBlock of missingBlocks) {
-      const { block: returnedBlock, didReorgHappened } = await reconcile({
-        client,
-        block: missingBlock,
-        unfinalizedBlocks,
-        finalizedBlock,
-        logger,
-        collector,
-        chain,
-        maxBatchSize
-      });
-      if (returnedBlock.number !== missingBlock.number)
-        return { block: returnedBlock, didReorgHappened, unfinalizedBlocks };
-    }
-    return reconcile({
-      client,
-      block,
-      unfinalizedBlocks,
-      finalizedBlock,
-      logger,
-      collector,
-      chain,
-      maxBatchSize
-    });
   }
-  if (block.parentHash !== latestBlock.hash) {
-    const ancestor = commonAncestor(block, unfinalizedBlocks) || finalizedBlock;
-    logger.info({
-      msg: `Reorg detected`,
-      collector,
-      chain_id: chain.id,
-      ancestor: ancestor.number,
-      block_range: [latestBlock.number, block.number]
-    });
-    unfinalizedBlocks = unfinalizedBlocks.filter((b) => b.number <= ancestor.number);
-    return { block: ancestor, didReorgHappened: true, unfinalizedBlocks };
+};
+var InvalidBatchSizeError = class extends BaseError {
+  name = "Chain.InvalidBatchSizeError";
+  constructor(maxBatchSize) {
+    super(
+      `Invalid batch size while streaming data from chain. Maximum is ${MAX_BATCH_SIZE}. Got ${maxBatchSize}.`
+    );
+  }
+};
+var MissingBlockNumberError = class extends BaseError {
+  name = "Chain.MissingBlockNumberError";
+  constructor() {
+    super("Missing block number when streaming data from chain in ascending order.");
   }
-  const newBlock = {
-    hash: block.hash,
-    number: block.number,
-    parentHash: block.parentHash
-  };
-  unfinalizedBlocks.push(newBlock);
-  return { block: newBlock, didReorgHappened: false, unfinalizedBlocks };
 };
 
-// src/collectors/Collector.ts
-var names = [
-  "mempool_offers",
-  "consumed_events",
-  "buy_with_empty_callback_liquidity",
-  "buy_vault_v1_callback_liquidity",
-  "sell_erc20_callback_liquidity"
-];
-function create2({
-  name,
-  collect,
-  client,
-  chain,
-  withTransaction,
-  collectorStore,
-  options
-}) {
-  const admin = create({
-    client,
-    chain,
-    withTransaction,
-    options
-  });
-  return {
-    name,
-    chain,
-    collect: lazy((emit) => {
-      const collector = name;
-      const logger = getLogger();
-      logger.info({
-        msg: `Collector started`,
-        collector,
-        chain_id: chain.id,
-        interval: options.interval
-      });
-      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);
-        },
-        { interval: options.interval }
-      );
-    })
-  };
-}
-function start(collector) {
-  let stopped = false;
-  const it = collector.collect();
-  (async () => {
-    while (!stopped) await it.next();
-    await it.return();
-  })();
-  return () => {
-    stopped = true;
-  };
-}
-
-// src/mempool/index.ts
-var mempool_exports = {};
-__export(mempool_exports, {
-  ChainIdMismatchError: () => ChainIdMismatchError,
-  ViemClientError: () => ViemClientError,
-  WalletAccountNotSetError: () => WalletAccountNotSetError,
-  add: () => add,
-  connect: () => connect,
-  from: () => from6,
-  get: () => get,
-  watch: () => watch
+// src/core/Collateral.ts
+var Collateral_exports = {};
+__export(Collateral_exports, {
+  CollateralSchema: () => CollateralSchema,
+  CollateralsSchema: () => CollateralsSchema,
+  from: () => from2
 });
+var transformHex = (val, ctx) => {
+  if (viem.isHex(val)) return val;
+  ctx.addIssue({
+    code: "invalid_format",
+    input: val,
+    format: "hex",
+    error: "not a hex"
+  });
+  return z6__namespace.NEVER;
+};
+var transformAddress = (val, ctx) => {
+  if (viem.isAddress(val.toLowerCase())) return val.toLowerCase();
+  ctx.addIssue({
+    code: "invalid_format",
+    input: val,
+    format: "address",
+    error: "not a valid address"
+  });
+  return z6__namespace.NEVER;
+};
 
-// src/core/Abi.ts
-var Abi_exports = {};
-__export(Abi_exports, {
-  ERC4626: () => ERC4626,
-  MetaMorpho: () => MetaMorpho,
-  MetaMorphoFactory: () => MetaMorphoFactory,
-  Morpho: () => Morpho,
-  Oracle: () => Oracle
+// src/core/LLTV.ts
+var LLTV_exports = {};
+__export(LLTV_exports, {
+  InvalidLLTVError: () => InvalidLLTVError,
+  InvalidOptionError: () => InvalidOptionError,
+  LLTVSchema: () => LLTVSchema,
+  Options: () => Options,
+  from: () => from
 });
-var Oracle = [
-  {
-    type: "function",
-    name: "price",
-    inputs: [],
-    outputs: [{ name: "", type: "uint256" }],
-    stateMutability: "view"
+var Options = [0.385, 0.5, 0.625, 0.77, 0.86, 0.915, 0.945, 0.965, 0.98];
+var LLTV_SCALED = Options.map((lltv) => BigInt(lltv * 10 ** 18));
+function from(lltv) {
+  if (typeof lltv === "bigint" && !LLTV_SCALED.includes(lltv)) throw new InvalidLLTVError(lltv);
+  if (typeof lltv === "bigint") return lltv;
+  if (typeof lltv === "number" && !Options.includes(lltv)) throw new InvalidOptionError(lltv);
+  return BigInt(lltv * 10 ** 18);
+}
+var InvalidOptionError = class extends BaseError {
+  name = "LLTV.InvalidOptionError";
+  constructor(input) {
+    super(
+      `Invalid LLTV option. Input: "${input}". Accepted values are: ${Options.map(
+        (option) => `"${option}"`
+      ).join(", ")}.`
+    );
   }
-];
-var ERC4626 = [
-  {
-    type: "function",
-    name: "asset",
-    inputs: [],
-    outputs: [{ name: "", type: "address" }],
-    stateMutability: "view"
+};
+var InvalidLLTVError = class extends BaseError {
+  name = "LLTV.InvalidLLTVError";
+  constructor(input) {
+    super(
+      `Invalid LLTV. Input: "${input}". Accepted values are: ${LLTV_SCALED.map(
+        (option) => `"${option}"`
+      ).join(", ")}.`
+    );
   }
-];
-var MetaMorphoFactory = [
+};
+var LLTVSchema = z6__namespace.bigint({ coerce: true }).refine(
+  (lltv) => {
+    try {
+      from(lltv);
+      return true;
+    } catch (_) {
+      return false;
+    }
+  },
   {
-    type: "function",
-    name: "isMetaMorpho",
-    inputs: [{ name: "target", type: "address" }],
-    outputs: [{ name: "", type: "bool" }],
-    stateMutability: "view"
+    error: () => {
+      return "Invalid LLTV: must be one of 0.385, 0.625, 0.77, 0.86, 0.915, 0.945, 0.965 or 0.98 (scaled by 1e18)";
+    }
   }
-];
-var MetaMorpho = [
-  {
-    type: "function",
-    name: "withdrawQueue",
-    inputs: [{ name: "index", type: "uint256" }],
-    outputs: [{ name: "", type: "bytes32" }],
-    stateMutability: "view"
+).transform((lltv) => from(lltv));
+
+// src/core/Collateral.ts
+var CollateralSchema = z6__namespace.object({
+  asset: z6__namespace.string().transform(transformAddress),
+  oracle: z6__namespace.string().transform(transformAddress),
+  lltv: LLTVSchema
+});
+var CollateralsSchema = z6__namespace.array(CollateralSchema).min(1, { message: "At least one collateral is required" }).refine(
+  (collaterals) => {
+    for (let i = 1; i < collaterals.length; i++) {
+      if (collaterals[i - 1].asset.toLowerCase() > collaterals[i].asset.toLowerCase()) {
+        return false;
+      }
+    }
+    return true;
   },
   {
-    type: "function",
-    name: "withdrawQueueLength",
-    inputs: [],
-    outputs: [{ name: "", type: "uint256" }],
-    stateMutability: "view"
+    message: "Collaterals must be sorted alphabetically by address"
+  }
+).refine(
+  (collaterals) => {
+    const uniqueAssets = /* @__PURE__ */ new Set();
+    for (const collateral of collaterals) {
+      const assetAddress = collateral.asset.toLowerCase();
+      if (uniqueAssets.has(assetAddress)) {
+        return false;
+      }
+      uniqueAssets.add(assetAddress);
+    }
+    return true;
   },
   {
-    type: "function",
-    name: "maxWithdraw",
-    inputs: [{ name: "owner", type: "address" }],
-    outputs: [{ name: "", type: "uint256" }],
-    stateMutability: "view"
+    message: "Collaterals must not contain duplicate assets"
   }
-];
-var Morpho = [
-  {
-    type: "function",
-    name: "collateralOf",
-    inputs: [
-      {
-        name: "",
-        type: "address",
-        internalType: "address"
-      },
-      {
-        name: "",
-        type: "bytes32",
-        internalType: "bytes32"
-      },
-      {
-        name: "",
-        type: "address",
-        internalType: "address"
-      }
-    ],
-    outputs: [
-      {
-        name: "",
-        type: "uint256",
-        internalType: "uint256"
-      }
-    ],
-    stateMutability: "view"
-  },
-  {
-    type: "function",
-    name: "debtOf",
-    inputs: [
-      {
-        name: "",
-        type: "address",
-        internalType: "address"
-      },
-      {
-        name: "",
-        type: "bytes32",
-        internalType: "bytes32"
-      }
-    ],
-    outputs: [
-      {
-        name: "",
-        type: "uint256",
-        internalType: "uint256"
-      }
-    ],
-    stateMutability: "view"
-  },
-  {
-    type: "function",
-    name: "market",
-    inputs: [
-      {
-        name: "id",
-        type: "bytes32",
-        internalType: "Id"
-      }
-    ],
-    outputs: [
-      {
-        name: "totalSupplyAssets",
-        type: "uint128",
-        internalType: "uint128"
-      },
-      {
-        name: "totalSupplyShares",
-        type: "uint128",
-        internalType: "uint128"
-      },
-      {
-        name: "totalBorrowAssets",
-        type: "uint128",
-        internalType: "uint128"
-      },
-      {
-        name: "totalBorrowShares",
-        type: "uint128",
-        internalType: "uint128"
-      },
-      {
-        name: "lastUpdate",
-        type: "uint128",
-        internalType: "uint128"
-      },
-      {
-        name: "fee",
-        type: "uint128",
-        internalType: "uint128"
-      }
-    ],
-    stateMutability: "view"
-  },
-  {
-    type: "function",
-    name: "position",
-    inputs: [
-      {
-        name: "id",
-        type: "bytes32",
-        internalType: "Id"
-      },
-      {
-        name: "user",
-        type: "address",
-        internalType: "address"
-      }
-    ],
-    outputs: [
-      {
-        name: "supplyShares",
-        type: "uint256",
-        internalType: "uint256"
-      },
-      {
-        name: "borrowShares",
-        type: "uint128",
-        internalType: "uint128"
-      },
-      {
-        name: "collateral",
-        type: "uint128",
-        internalType: "uint128"
-      }
-    ],
-    stateMutability: "view"
-  }
-];
+);
+var from2 = (parameters) => {
+  return {
+    asset: parameters.asset.toLowerCase(),
+    lltv: from(parameters.lltv),
+    oracle: parameters.oracle.toLowerCase()
+  };
+};
 
-// src/core/Callback.ts
-var Callback_exports = {};
-__export(Callback_exports, {
-  CallbackType: () => CallbackType,
-  WhitelistedCallbackAddresses: () => WhitelistedCallbackAddresses,
-  decodeBuyVaultV1Callback: () => decodeBuyVaultV1Callback,
-  decodeSellERC20Callback: () => decodeSellERC20Callback,
-  encodeBuyVaultV1Callback: () => encodeBuyVaultV1Callback,
-  encodeSellERC20Callback: () => encodeSellERC20Callback
+// src/core/Liquidity.ts
+var Liquidity_exports = {};
+__export(Liquidity_exports, {
+  calculateMaxDebt: () => calculateMaxDebt,
+  generateAllowancePoolId: () => generateAllowancePoolId,
+  generateBalancePoolId: () => generateBalancePoolId,
+  generateBuyVaultCallbackPoolId: () => generateBuyVaultCallbackPoolId,
+  generateDebtPoolId: () => generateDebtPoolId,
+  generateMarketLiquidityPoolId: () => generateMarketLiquidityPoolId,
+  generateObligationCollateralPoolId: () => generateObligationCollateralPoolId,
+  generateSellERC20CallbackPoolId: () => generateSellERC20CallbackPoolId,
+  generateUserVaultPositionPoolId: () => generateUserVaultPositionPoolId,
+  generateVaultPositionPoolId: () => generateVaultPositionPoolId
 });
-var CallbackType = /* @__PURE__ */ ((CallbackType2) => {
-  CallbackType2["BuyWithEmptyCallback"] = "buy_with_empty_callback";
-  CallbackType2["BuyVaultV1Callback"] = "buy_vault_v1_callback";
-  CallbackType2["SellERC20Callback"] = "sell_erc20_callback";
-  return CallbackType2;
-})(CallbackType || {});
-var WhitelistedCallbackAddresses = {
-  ["buy_with_empty_callback" /* BuyWithEmptyCallback */]: [],
-  ["buy_vault_v1_callback" /* BuyVaultV1Callback */]: [
-    "0x3333333333333333333333333333333333333333",
-    "0x4444444444444444444444444444444444444444"
-    // @TODO: update once deployed and add mapping per chain if needed
-  ].map((address) => address.toLowerCase()),
-  ["sell_erc20_callback" /* SellERC20Callback */]: [
-    "0x1111111111111111111111111111111111111111",
-    "0x2222222222222222222222222222222222222222"
-    // @TODO: update once deployed and add mapping per chain if needed
-  ].map((address) => address.toLowerCase())
-};
-function decodeBuyVaultV1Callback(data) {
-  if (!data || data === "0x") throw new Error("Empty callback data");
-  try {
-    const [vaults, amounts] = viem.decodeAbiParameters(
-      [{ type: "address[]" }, { type: "uint256[]" }],
-      data
-    );
-    if (vaults.length !== amounts.length) {
-      throw new Error("Mismatched array lengths");
-    }
-    return vaults.map((v, i) => ({ vault: v, amount: amounts[i] }));
-  } catch (_) {
-    throw new Error("Invalid BuyVaultV1Callback callback data");
-  }
+function calculateMaxDebt(amount, oraclePrice, lltv) {
+  const ORACLE_PRICE_SCALE = 10n ** 36n;
+  const PRECISION = 10n ** 18n;
+  const collateralQuoted = amount * oraclePrice / ORACLE_PRICE_SCALE;
+  const maxDebt = collateralQuoted * lltv / PRECISION;
+  return maxDebt;
 }
-function decodeSellERC20Callback(data) {
-  if (!data || data === "0x") throw new Error("Empty callback data");
-  try {
-    const [collaterals, amounts] = viem.decodeAbiParameters(
-      [{ type: "address[]" }, { type: "uint256[]" }],
-      data
-    );
-    if (collaterals.length !== amounts.length) {
-      throw new Error("Mismatched array lengths");
-    }
-    return collaterals.map((c, i) => ({ collateral: c, amount: amounts[i] }));
-  } catch (_) {
-    throw new Error("Invalid SellERC20Callback callback data");
-  }
+function generateBalancePoolId(parameters) {
+  const { user, chainId, token } = parameters;
+  return `${user}-${chainId.toString()}-${token}-balance`.toLowerCase();
 }
-function encodeBuyVaultV1Callback(parameters) {
-  return viem.encodeAbiParameters(
-    [{ type: "address[]" }, { type: "uint256[]" }],
-    [parameters.vaults, parameters.amounts]
-  );
+function generateAllowancePoolId(parameters) {
+  const { user, chainId, token } = parameters;
+  return `${user}-${chainId.toString()}-${token}-allowance`.toLowerCase();
 }
-function encodeSellERC20Callback(parameters) {
-  return viem.encodeAbiParameters(
-    [{ type: "address[]" }, { type: "uint256[]" }],
-    [parameters.collaterals, parameters.amounts]
-  );
+function generateSellERC20CallbackPoolId(parameters) {
+  const { user, chainId, obligationId: obligationId2, token, offerHash } = parameters;
+  return `${user}-${chainId.toString()}-${obligationId2}-${token}-${offerHash}-sell_erc20_callback`.toLowerCase();
+}
+function generateObligationCollateralPoolId(parameters) {
+  const { user, chainId, obligationId: obligationId2, token } = parameters;
+  return `${user}-${chainId.toString()}-${obligationId2}-${token}-obligation-collateral`.toLowerCase();
+}
+function generateBuyVaultCallbackPoolId(parameters) {
+  const { user, chainId, vault, offerHash } = parameters;
+  return `${user}-${chainId.toString()}-${vault}-${offerHash}-${"buy_vault_v1_callback" /* BuyVaultV1Callback */}`.toLowerCase();
+}
+function generateDebtPoolId(parameters) {
+  const { user, chainId, obligationId: obligationId2 } = parameters;
+  return `${user}-${chainId.toString()}-${obligationId2}-debt`.toLowerCase();
+}
+function generateUserVaultPositionPoolId(parameters) {
+  const { user, chainId, vault } = parameters;
+  return `${user}-${chainId.toString()}-${vault}-user-vault-position`.toLowerCase();
+}
+function generateVaultPositionPoolId(parameters) {
+  const { vault, chainId, marketId } = parameters;
+  return `${vault}-${chainId.toString()}-${marketId}-vault-position`.toLowerCase();
+}
+function generateMarketLiquidityPoolId(parameters) {
+  const { chainId, marketId } = parameters;
+  return `${chainId.toString()}-${marketId}-market-liquidity`.toLowerCase();
 }
 
-// src/core/Chain.ts
-var Chain_exports = {};
-__export(Chain_exports, {
-  ChainId: () => ChainId,
-  InvalidBatchSizeError: () => InvalidBatchSizeError,
-  InvalidBlockRangeError: () => InvalidBlockRangeError,
-  InvalidBlockWindowError: () => InvalidBlockWindowError,
-  MissingBlockNumberError: () => MissingBlockNumberError,
-  chainIds: () => chainIds,
-  chainNames: () => chainNames,
-  chains: () => chains,
-  getChain: () => getChain,
-  getWhitelistedChains: () => getWhitelistedChains,
-  streamLogs: () => streamLogs
+// src/core/Maturity.ts
+var Maturity_exports = {};
+__export(Maturity_exports, {
+  InvalidDateError: () => InvalidDateError,
+  InvalidFormatError: () => InvalidFormatError,
+  InvalidOptionError: () => InvalidOptionError2,
+  MaturitySchema: () => MaturitySchema,
+  from: () => from3
 });
-var chainNames = ["ethereum", "base", "ethereum-virtual-testnet", "anvil"];
-var ChainId = {
-  ETHEREUM: BigInt(chains$1.mainnet.id),
-  BASE: BigInt(chains$1.base.id),
-  "ETHEREUM-VIRTUAL-TESTNET": 109111114n,
-  ANVIL: 505050505n
-  // random id to not clash with other chains
-};
-var chainIds = new Set(Object.values(ChainId));
-var chainNameLookup = new Map(Object.entries(ChainId).map(([key, value]) => [value, key]));
-function getChain(chainId) {
-  const chainName = chainNameLookup.get(chainId)?.toLowerCase();
-  if (!chainName) {
-    return void 0;
-  }
-  return chains[chainName];
-}
-var getWhitelistedChains = () => {
-  return [chains.ethereum, chains.base, chains["ethereum-virtual-testnet"], chains.anvil];
-};
-var chains = {
-  ethereum: {
-    ...chains$1.mainnet,
-    id: ChainId.ETHEREUM,
-    name: "ethereum",
-    whitelistedAssets: new Set(
-      [
-        "0xA0b86991c6218b36c1d19D4a2e9Eb0cE3606eB48",
-        // USDC
-        "0x6B175474E89094C44Da98b954EedeAC495271d0F"
-        // DAI
-      ].map((address) => address.toLowerCase())
-    ),
-    morpho: "0x0000000000000000000000000000000000000000",
-    morphoBlue: "0xBBBBBbbBBb9cC5e90e3b3Af64bdAF62C37EEFFCb",
-    mempool: {
-      address: "0x0000000000000000000000000000000000000000",
-      deploymentBlock: 23347674,
-      reindexBuffer: 10
-    },
-    vaultV1Factory: {
-      "v1.0": "0xA9c3D3a366466Fa809d1Ae982Fb2c46E5fC41101",
-      "v1.1": "0x1897A8997241C1cD4bD0698647e4EB7213535c24"
-    }
-  },
-  base: {
-    ...chains$1.base,
-    id: ChainId.BASE,
-    name: "base",
-    whitelistedAssets: new Set(
-      [
-        "0x833589fCD6eDb6E08f4c7C32D4f71b54bdA02913",
-        // USDC
-        "0x50c5725949A6F0c72E6C4a641F24049A917DB0Cb"
-        // DAI
-      ].map((address) => address.toLowerCase())
-    ),
-    morpho: "0x0000000000000000000000000000000000000000",
-    morphoBlue: "0xBBBBBbbBBb9cC5e90e3b3Af64bdAF62C37EEFFCb",
-    mempool: {
-      address: "0x0000000000000000000000000000000000000000",
-      deploymentBlock: 35449942,
-      reindexBuffer: 10
-    },
-    vaultV1Factory: {
-      "v1.0": "0xA9c3D3a366466Fa809d1Ae982Fb2c46E5fC41101",
-      "v1.1": "0xFf62A7c278C62eD665133147129245053Bbf5918"
-    }
-  },
-  "ethereum-virtual-testnet": {
-    ...chains$1.mainnet,
-    id: ChainId["ETHEREUM-VIRTUAL-TESTNET"],
-    name: "ethereum-virtual-testnet",
-    whitelistedAssets: new Set(
-      [
-        "0xA0b86991c6218b36c1d19D4a2e9Eb0cE3606eB48",
-        // USDC
-        "0x6B175474E89094C44Da98b954EedeAC495271d0F"
-        // DAI
-      ].map((address) => address.toLowerCase())
-    ),
-    morpho: "0x11a002d45db720ed47a80d2f3489cba5b833eaf5",
-    // @TODO: This is mock Consumed contract, update with Terms once stable
-    morphoBlue: "0xBBBBBbbBBb9cC5e90e3b3Af64bdAF62C37EEFFCb",
-    mempool: {
-      address: "0x5b06224f736a57635b5bcb50b8ef178b189107cb",
-      deploymentBlock: 23224302,
-      reindexBuffer: 10
-    },
-    vaultV1Factory: {
-      "v1.0": "0xA9c3D3a366466Fa809d1Ae982Fb2c46E5fC41101",
-      "v1.1": "0x1897A8997241C1cD4bD0698647e4EB7213535c24"
+var MaturitySchema = z6__namespace.number().int().refine(
+  (maturity) => {
+    try {
+      from3(maturity);
+      return true;
+    } catch (_e) {
+      return false;
     }
   },
-  anvil: {
-    ...chains$1.anvil,
-    id: ChainId.ANVIL,
-    name: "anvil",
-    whitelistedAssets: new Set(
-      [
-        "0xA0b86991c6218b36c1d19D4a2e9Eb0cE3606eB48",
-        // USDC
-        "0x6B175474E89094C44Da98b954EedeAC495271d0F"
-        // DAI
-      ].map((address) => address.toLowerCase())
-    ),
-    morpho: "0x23DFBc4B8B80C14CC5e25011B8491f268395BAd6",
-    morphoBlue: "0x0000000000000000000000000000000000000000",
-    // Set dynamically in tests
-    mempool: {
-      address: "0xD946246695A9259F3B33a78629026F61B3Ab40aF",
-      deploymentBlock: 23223727,
-      reindexBuffer: 10
-    },
-    vaultV1Factory: {
-      "v1.0": "0x0000000000000000000000000000000000000000",
-      "v1.1": "0x0000000000000000000000000000000000000000"
+  {
+    error: (issue) => {
+      try {
+        const maturityDate = new Date(issue.input * 1e3);
+        return `The maturity is set to ${maturityDate}. It must fall on the allowed settlement cycles (Friday 15:00 UTC at the end of week/month/quarter).`;
+      } catch (_) {
+        return `The maturity is set to ${issue.input}. It must fall on the allowed settlement cycles (Friday 15:00 UTC at the end of week/month/quarter).`;
+      }
     }
   }
+).transform((maturity) => maturity);
+var MaturityOptions = {
+  end_of_week: () => endOfWeek(),
+  end_of_next_week: () => endOfNextWeek(),
+  end_of_month: () => endOfMonth(),
+  end_of_next_month: () => endOfNextMonth(),
+  end_of_quarter: () => endOfQuarter(),
+  end_of_next_quarter: () => endOfNextQuarter()
 };
-var MAX_BATCH_SIZE = 1e4;
-var DEFAULT_BATCH_SIZE = 2500;
-var MAX_BLOCK_WINDOW = 2e3;
-var DEFAULT_BLOCK_WINDOW = 500;
-async function* streamLogs(parameters) {
-  const {
-    client,
-    contractAddress,
-    event,
-    blockNumberGte,
-    blockNumberLte,
-    order = "desc",
-    options: { maxBatchSize = DEFAULT_BATCH_SIZE, blockWindow = DEFAULT_BLOCK_WINDOW } = {}
-  } = parameters;
-  if (maxBatchSize > MAX_BATCH_SIZE) throw new InvalidBatchSizeError(maxBatchSize);
-  if (blockWindow > MAX_BLOCK_WINDOW) throw new InvalidBlockWindowError(blockWindow);
-  if (order === "asc" && blockNumberGte === void 0) throw new MissingBlockNumberError();
-  const latestBlock = (await actions.getBlock(client, { blockTag: "latest", includeTransactions: false })).number;
-  let toBlock = 0n;
-  if (order === "asc")
-    toBlock = min(BigInt(blockNumberGte) + BigInt(blockWindow), latestBlock);
-  if (order === "desc")
-    toBlock = blockNumberLte === void 0 ? latestBlock : min(BigInt(blockNumberLte), latestBlock);
-  let fromBlock = 0n;
-  if (order === "asc") fromBlock = min(BigInt(blockNumberGte), latestBlock);
-  if (order === "desc")
-    fromBlock = max(BigInt(blockNumberGte || toBlock - BigInt(blockWindow)), 0n);
-  if (order === "asc") toBlock = min(toBlock, fromBlock + BigInt(blockWindow));
-  if (order === "desc") fromBlock = max(fromBlock, toBlock - BigInt(blockWindow));
-  if (fromBlock > toBlock) throw new InvalidBlockRangeError(fromBlock, toBlock);
-  let streaming = true;
-  while (streaming) {
-    const logs = await actions.getLogs(client, {
-      address: contractAddress,
-      event,
-      fromBlock,
-      toBlock
-    });
-    logs.sort((a, b) => {
-      if (a.blockNumber !== b.blockNumber)
-        return order === "asc" ? Number(a.blockNumber - b.blockNumber) : Number(b.blockNumber - a.blockNumber);
-      if (a.transactionIndex !== b.transactionIndex)
-        return order === "asc" ? a.transactionIndex - b.transactionIndex : b.transactionIndex - a.transactionIndex;
-      return order === "asc" ? a.logIndex - b.logIndex : b.logIndex - a.logIndex;
-    });
-    for (const logBatch of batch(logs, maxBatchSize)) {
-      if (logBatch.length === 0) break;
-      yield {
-        logs: logBatch,
-        blockNumber: logBatch.length === maxBatchSize ? (
-          // if the batch is full, return the last block number, block numbers are always sorted
-          Number(logBatch[logBatch.length - 1]?.blockNumber)
-        ) : (
-          // if the batch is not full, return `toBlock` or `fromBlock` to indicate until which block the logs were fetched
-          order === "asc" ? Number(toBlock) : Number(fromBlock)
-        )
-      };
-    }
-    streaming = order === "asc" ? toBlock < (blockNumberLte || latestBlock) : fromBlock > (blockNumberGte || 0n);
-    if (order === "asc") {
-      fromBlock = min(BigInt(toBlock) + 1n, latestBlock);
-      toBlock = min(fromBlock + BigInt(blockWindow), latestBlock);
-    }
-    if (order === "desc") {
-      const lowerBound = BigInt(blockNumberGte || 0);
-      const windowSize = BigInt(blockWindow);
-      const nextToBlock = max(fromBlock - 1n, lowerBound);
-      const nextFromBlock = max(nextToBlock - windowSize, lowerBound);
-      toBlock = nextToBlock;
-      fromBlock = nextFromBlock;
-    }
+function from3(ts) {
+  if (typeof ts === "string") {
+    if (ts in MaturityOptions) return MaturityOptions[ts]();
+    throw new InvalidOptionError2(ts);
   }
-  yield { logs: [], blockNumber: order === "asc" ? Number(toBlock) : Number(fromBlock) };
-  return;
+  if (typeof ts === "number" && ts > 1e12) throw new InvalidFormatError();
+  if (!Object.values(MaturityOptions).some((option) => option() === ts))
+    throw new InvalidDateError(ts);
+  return ts;
 }
-var InvalidBlockRangeError = class extends BaseError {
-  name = "Chain.InvalidBlockRangeError";
-  constructor(fromBlock, toBlock) {
-    super(
-      `Invalid block range while streaming data from chain. From block ${fromBlock} to block ${toBlock}.`
-    );
+var endOfWeek = () => fridayOfWeek(0);
+var endOfNextWeek = () => fridayOfWeek(1);
+var endOfMonth = () => lastFridayOfMonth((/* @__PURE__ */ new Date()).getUTCFullYear(), (/* @__PURE__ */ new Date()).getUTCMonth());
+var endOfNextMonth = () => lastFridayOfMonth((/* @__PURE__ */ new Date()).getUTCFullYear(), (/* @__PURE__ */ new Date()).getUTCMonth() + 1);
+var endOfQuarter = () => lastFridayOfQuarter(0);
+var endOfNextQuarter = () => lastFridayOfQuarter(1);
+var fridayOfWeek = (weeksAhead = 0) => {
+  const now2 = /* @__PURE__ */ new Date();
+  const today15H = new Date(
+    Date.UTC(now2.getUTCFullYear(), now2.getUTCMonth(), now2.getUTCDate(), 15)
+  );
+  let daysUntilFriday = (5 - today15H.getUTCDay() + 7) % 7;
+  if (daysUntilFriday === 0 && now2.getTime() >= today15H.getTime()) {
+    daysUntilFriday = 7;
   }
+  const friday = new Date(today15H);
+  friday.setUTCDate(friday.getUTCDate() + daysUntilFriday + weeksAhead * 7);
+  return friday.getTime() / 1e3;
 };
-var InvalidBlockWindowError = class extends BaseError {
-  name = "Chain.InvalidBlockWindowError";
-  constructor(blockWindow) {
-    super(
-      `Invalid block window while streaming data from chain. Maximum is ${MAX_BLOCK_WINDOW}. Got ${blockWindow}.`
-    );
+var lastFridayOfMonth = (year, month) => {
+  const lastDayOfMonth15H = new Date(Date.UTC(year, month + 1, 0, 15));
+  while (lastDayOfMonth15H.getUTCDay() !== 5) {
+    lastDayOfMonth15H.setUTCDate(lastDayOfMonth15H.getUTCDate() - 1);
   }
+  const maturity = lastDayOfMonth15H.setUTCDate(lastDayOfMonth15H.getUTCDate()) / 1e3;
+  return maturity;
 };
-var InvalidBatchSizeError = class extends BaseError {
-  name = "Chain.InvalidBatchSizeError";
-  constructor(maxBatchSize) {
-    super(
-      `Invalid batch size while streaming data from chain. Maximum is ${MAX_BATCH_SIZE}. Got ${maxBatchSize}.`
-    );
-  }
+var lastFridayOfQuarter = (quartersAhead = 0) => {
+  const now2 = /* @__PURE__ */ new Date();
+  const quarterIndex = Math.floor(now2.getUTCMonth() / 3) + quartersAhead;
+  const year = now2.getUTCFullYear() + Math.floor(quarterIndex / 4);
+  const quarter = quarterIndex % 4;
+  const lastMonth = quarter * 3 + 2;
+  return lastFridayOfMonth(year, lastMonth);
 };
-var MissingBlockNumberError = class extends BaseError {
-  name = "Chain.MissingBlockNumberError";
+var InvalidFormatError = class extends BaseError {
+  name = "Maturity.InvalidFormatError";
   constructor() {
-    super("Missing block number when streaming data from chain in ascending order.");
+    super("Invalid maturity format. Maturity should be expressed in seconds.");
   }
 };
-
-// src/core/Collateral.ts
-var Collateral_exports = {};
-__export(Collateral_exports, {
-  CollateralSchema: () => CollateralSchema,
-  CollateralsSchema: () => CollateralsSchema,
-  from: () => from2
-});
-var transformHex = (val, ctx) => {
-  if (viem.isHex(val)) return val;
-  ctx.addIssue({
-    code: "invalid_format",
-    input: val,
-    format: "hex",
-    error: "not a hex"
-  });
-  return z6__namespace.NEVER;
-};
-var transformAddress = (val, ctx) => {
-  if (viem.isAddress(val.toLowerCase())) return val.toLowerCase();
-  ctx.addIssue({
-    code: "invalid_format",
-    input: val,
-    format: "address",
-    error: "not a valid address"
-  });
-  return z6__namespace.NEVER;
-};
-
-// src/core/LLTV.ts
-var LLTV_exports = {};
-__export(LLTV_exports, {
-  InvalidLLTVError: () => InvalidLLTVError,
-  InvalidOptionError: () => InvalidOptionError,
-  LLTVSchema: () => LLTVSchema,
-  Options: () => Options,
-  from: () => from
-});
-var Options = [0.385, 0.5, 0.625, 0.77, 0.86, 0.915, 0.945, 0.965, 0.98];
-var LLTV_SCALED = Options.map((lltv) => BigInt(lltv * 10 ** 18));
-function from(lltv) {
-  if (typeof lltv === "bigint" && !LLTV_SCALED.includes(lltv)) throw new InvalidLLTVError(lltv);
-  if (typeof lltv === "bigint") return lltv;
-  if (typeof lltv === "number" && !Options.includes(lltv)) throw new InvalidOptionError(lltv);
-  return BigInt(lltv * 10 ** 18);
-}
-var InvalidOptionError = class extends BaseError {
-  name = "LLTV.InvalidOptionError";
+var InvalidDateError = class extends BaseError {
+  name = "Maturity.InvalidDateError";
   constructor(input) {
     super(
-      `Invalid LLTV option. Input: "${input}". Accepted values are: ${Options.map(
-        (option) => `"${option}"`
-      ).join(", ")}.`
+      `Invalid maturity date. Input: "${input}". Accepted values are: ${Object.values(
+        MaturityOptions
+      ).map((option) => `"${option()}"`).join(", ")}.`
     );
   }
 };
-var InvalidLLTVError = class extends BaseError {
-  name = "LLTV.InvalidLLTVError";
+var InvalidOptionError2 = class extends BaseError {
+  name = "Maturity.InvalidOptionError";
   constructor(input) {
     super(
-      `Invalid LLTV. Input: "${input}". Accepted values are: ${LLTV_SCALED.map(
-        (option) => `"${option}"`
-      ).join(", ")}.`
+      `Invalid maturity option. Input: "${input}". Accepted values are: ${Object.keys(
+        MaturityOptions
+      ).map((option) => `"${option}"`).join(", ")}.`
     );
   }
 };
-var LLTVSchema = z6__namespace.bigint({ coerce: true }).refine(
-  (lltv) => {
-    try {
-      from(lltv);
-      return true;
-    } catch (_) {
-      return false;
-    }
-  },
-  {
-    error: () => {
-      return "Invalid LLTV: must be one of 0.385, 0.625, 0.77, 0.86, 0.915, 0.945, 0.965 or 0.98 (scaled by 1e18)";
-    }
-  }
-).transform((lltv) => from(lltv));
 
-// src/core/Collateral.ts
-var CollateralSchema = z6__namespace.object({
-  asset: z6__namespace.string().transform(transformAddress),
-  oracle: z6__namespace.string().transform(transformAddress),
-  lltv: LLTVSchema
+// src/core/Obligation.ts
+var Obligation_exports = {};
+__export(Obligation_exports, {
+  CollateralsAreNotSortedError: () => CollateralsAreNotSortedError,
+  InvalidObligationError: () => InvalidObligationError,
+  ObligationSchema: () => ObligationSchema,
+  from: () => from4,
+  fromSnakeCase: () => fromSnakeCase2,
+  id: () => id,
+  random: () => random
 });
-var CollateralsSchema = z6__namespace.array(CollateralSchema).min(1, { message: "At least one collateral is required" }).refine(
-  (collaterals) => {
-    for (let i = 1; i < collaterals.length; i++) {
-      if (collaterals[i - 1].asset.toLowerCase() > collaterals[i].asset.toLowerCase()) {
-        return false;
-      }
-    }
-    return true;
-  },
-  {
-    message: "Collaterals must be sorted alphabetically by address"
-  }
-).refine(
-  (collaterals) => {
-    const uniqueAssets = /* @__PURE__ */ new Set();
-    for (const collateral of collaterals) {
-      const assetAddress = collateral.asset.toLowerCase();
-      if (uniqueAssets.has(assetAddress)) {
-        return false;
-      }
-      uniqueAssets.add(assetAddress);
+
+// src/utils/Format.ts
+var Format_exports = {};
+__export(Format_exports, {
+  fromSnakeCase: () => fromSnakeCase,
+  toSnakeCase: () => toSnakeCase
+});
+function toSnakeCase(obj) {
+  return stringifyBigint(
+    processObject(
+      obj,
+      (s2) => s2.replace(/[A-Z]/g, (c) => `_${c.toLowerCase()}`),
+      (value) => typeof value === "string" && viem.isAddress(value.toLowerCase()) ? viem.getAddress(value.toLowerCase()) : value
+    )
+  );
+}
+function fromSnakeCase(obj) {
+  return processObject(
+    obj,
+    (s2) => viem.isAddress(s2.toLowerCase()) ? s2 : s2.replace(/_([a-z])/g, (_, c) => c.toUpperCase()),
+    (value) => typeof value === "string" && viem.isAddress(value.toLowerCase()) ? value.toLowerCase() : value
+  );
+}
+function processObject(obj, fnKey, fnValue) {
+  if (typeof obj !== "object" || obj === null) return obj;
+  if (Array.isArray(obj)) return obj.map((item) => processObject(item, fnKey, fnValue));
+  return Object.entries(obj).reduce(
+    (acc, [key, value]) => {
+      const newKey = fnKey(key);
+      acc[newKey] = typeof value === "object" && value !== null ? processObject(value, fnKey, fnValue) : fnValue(value);
+      return acc;
+    },
+    {}
+  );
+}
+function stringifyBigint(value) {
+  if (typeof value === "bigint") return value.toString();
+  if (Array.isArray(value)) return value.map(stringifyBigint);
+  if (value && typeof value === "object") {
+    const out = {};
+    for (const [k, v] of Object.entries(value)) {
+      out[k] = stringifyBigint(v);
     }
-    return true;
-  },
-  {
-    message: "Collaterals must not contain duplicate assets"
+    return out;
   }
-);
-var from2 = (parameters) => {
-  return {
-    asset: parameters.asset.toLowerCase(),
-    lltv: from(parameters.lltv),
-    oracle: parameters.oracle.toLowerCase()
-  };
-};
+  return value;
+}
 
-// src/core/Cursor.ts
-var Cursor_exports = {};
-__export(Cursor_exports, {
-  decode: () => decode,
-  encode: () => encode,
-  validate: () => validate
+// src/core/Obligation.ts
+var ObligationSchema = z6__namespace.object({
+  chainId: z6__namespace.bigint({ coerce: true }).min(0n).max(viem.maxUint256),
+  loanToken: z6__namespace.string().transform(transformAddress),
+  collaterals: CollateralsSchema,
+  maturity: MaturitySchema
 });
-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`
-    );
+function from4(parameters) {
+  try {
+    const parsedObligation = ObligationSchema.parse({
+      ...parameters,
+      maturity: from3(parameters.maturity)
+    });
+    return {
+      chainId: parsedObligation.chainId,
+      loanToken: parsedObligation.loanToken.toLowerCase(),
+      collaterals: parsedObligation.collaterals.sort((a, b) => a.asset.localeCompare(b.asset)),
+      maturity: parsedObligation.maturity
+    };
+  } catch (error2) {
+    throw new InvalidObligationError(error2);
   }
-  if (!["asc", "desc"].includes(c.dir)) {
-    throw new Error(`Invalid direction: ${c.dir}. Must be one of: asc, desc`);
+}
+function fromSnakeCase2(input) {
+  return from4(fromSnakeCase(input));
+}
+function id(obligation) {
+  let lastAsset = "";
+  for (const collateral of obligation.collaterals) {
+    const newAsset = collateral.asset.toLowerCase();
+    if (newAsset.localeCompare(lastAsset) < 0) throw new CollateralsAreNotSortedError();
+    lastAsset = newAsset;
   }
-  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`);
+  return viem.keccak256(
+    viem.encodeAbiParameters(
+      [
+        { type: "uint256" },
+        { type: "address" },
+        {
+          type: "tuple[]",
+          components: [
+            { type: "address", name: "token" },
+            { type: "uint256", name: "lltv" },
+            { type: "address", name: "oracle" }
+          ]
+        },
+        { type: "uint256" }
+      ],
+      [
+        obligation.chainId,
+        obligation.loanToken.toLowerCase(),
+        obligation.collaterals.map((c) => ({
+          token: c.asset.toLowerCase(),
+          lltv: c.lltv,
+          oracle: c.oracle.toLowerCase()
+        })),
+        BigInt(obligation.maturity)
+      ]
+    )
+  );
+}
+function random() {
+  return from4({
+    chainId: 1n,
+    loanToken: accounts.privateKeyToAccount(accounts.generatePrivateKey()).address,
+    collaterals: [
+      from2({
+        asset: accounts.privateKeyToAccount(accounts.generatePrivateKey()).address,
+        oracle: accounts.privateKeyToAccount(accounts.generatePrivateKey()).address,
+        lltv: 0.965
+      })
+    ],
+    maturity: from3("end_of_next_quarter")
+  });
+}
+var InvalidObligationError = class extends BaseError {
+  name = "Obligation.InvalidObligationError";
+  constructor(error2) {
+    super("Invalid obligation.", { cause: error2 });
   }
-  if (typeof fieldValue !== validation.type) {
-    throw new Error(
-      `${c.sort} sort requires '${validation.field}' field of type ${validation.type}`
-    );
+};
+var CollateralsAreNotSortedError = class extends BaseError {
+  name = "Obligation.CollateralsAreNotSortedError";
+  constructor() {
+    super("Collaterals are not sorted alphabetically by address.");
   }
-  if (validation.pattern && !validation.pattern.test(fieldValue)) {
-    throw new Error(
-      `Invalid ${validation.field} format: ${fieldValue}. Must be a ${validation.error}`
-    );
+};
+
+// src/core/Offer.ts
+var Offer_exports = {};
+__export(Offer_exports, {
+  AccountNotSetError: () => AccountNotSetError,
+  InvalidOfferError: () => InvalidOfferError,
+  OfferHashSchema: () => OfferHashSchema,
+  OfferSchema: () => OfferSchema,
+  consumedEvent: () => consumedEvent,
+  decode: () => decode,
+  domain: () => domain,
+  encode: () => encode,
+  from: () => from5,
+  fromConsumedLog: () => fromConsumedLog,
+  fromSnakeCase: () => fromSnakeCase3,
+  hash: () => hash,
+  obligationId: () => obligationId,
+  random: () => random2,
+  sign: () => sign,
+  toSnakeCase: () => toSnakeCase2,
+  types: () => types
+});
+
+// src/utils/index.ts
+var utils_exports = {};
+__export(utils_exports, {
+  BaseError: () => BaseError,
+  Time: () => time_exports,
+  batch: () => batch,
+  batchMulticall: () => batchMulticall,
+  fromSnakeCase: () => fromSnakeCase,
+  lazy: () => lazy,
+  max: () => max,
+  min: () => min,
+  poll: () => poll,
+  retry: () => retry,
+  toSnakeCase: () => toSnakeCase,
+  wait: () => wait
+});
+
+// src/utils/retry.ts
+var retry = async (fn, attempts = 3, delayMs = 50) => {
+  let lastErr;
+  for (let i = 0; i < attempts; i++) {
+    try {
+      return await fn();
+    } catch (err) {
+      lastErr = err;
+      if (i < attempts - 1) await new Promise((r) => setTimeout(r, delayMs));
+    }
   }
-  if (validation.validator && !validation.validator(fieldValue)) {
-    throw new Error(
-      `Invalid ${validation.field} value: ${fieldValue}. Must be a ${validation.error}`
+  throw lastErr;
+};
+
+// src/utils/batchMulticall.ts
+async function batchMulticall(parameters) {
+  const { client, calls, batchSize, retryAttempts, retryDelayMs, blockNumber } = parameters;
+  const results = [];
+  for (const callsBatch of batch(calls, batchSize)) {
+    const batchResults = await retry(
+      () => client.multicall({
+        allowFailure: false,
+        contracts: callsBatch,
+        ...blockNumber ? { blockNumber } : {}
+      }),
+      retryAttempts,
+      retryDelayMs
     );
+    results.push(...batchResults);
   }
-  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 results;
+}
+
+// src/utils/lazy.ts
+function lazy(pollFn) {
+  return () => async function* () {
+    let active = true;
+    let resolveNext = null;
+    const queue = [];
+    const wait2 = () => new Promise((resolve) => {
+      resolveNext = resolve;
+    });
+    const emit = (item) => {
+      queue.push(item);
+      resolveNext?.();
+      resolveNext = null;
+    };
+    let unpoll = null;
+    const stop = () => {
+      active = false;
+      unpoll?.();
+      resolveNext?.();
+      resolveNext = null;
+    };
+    unpoll = pollFn(emit, { stop });
+    try {
+      while (active) {
+        if (queue.length === 0) await wait2();
+        while (queue.length > 0 && active) yield queue.shift();
+      }
+    } finally {
+      stop();
     }
-  }
-  return true;
+  }();
 }
-function encode(c) {
-  return jsBase64.Base64.encodeURL(JSON.stringify(c));
+
+// src/utils/wait.ts
+async function wait(time) {
+  return new Promise((res) => setTimeout(res, time));
 }
-function decode(token) {
-  if (!token) return null;
-  const decoded = JSON.parse(jsBase64.Base64.decode(token));
-  validate(decoded);
-  return decoded;
+
+// src/utils/poll.ts
+function poll(fn, { interval }) {
+  let active = true;
+  const unwatch = () => active = false;
+  const watch2 = async () => {
+    await wait(interval);
+    const poll2 = async () => {
+      if (!active) return;
+      await fn({ unpoll: unwatch });
+      await wait(interval);
+      poll2();
+    };
+    poll2();
+  };
+  watch2();
+  return unwatch;
 }
 
-// src/core/Liquidity.ts
-var Liquidity_exports = {};
-__export(Liquidity_exports, {
-  calculateMaxDebt: () => calculateMaxDebt,
-  generateAllowancePoolId: () => generateAllowancePoolId,
-  generateBalancePoolId: () => generateBalancePoolId,
-  generateBuyVaultCallbackPoolId: () => generateBuyVaultCallbackPoolId,
-  generateDebtPoolId: () => generateDebtPoolId,
-  generateMarketLiquidityPoolId: () => generateMarketLiquidityPoolId,
-  generateObligationCollateralPoolId: () => generateObligationCollateralPoolId,
-  generateSellERC20CallbackPoolId: () => generateSellERC20CallbackPoolId,
-  generateUserVaultPositionPoolId: () => generateUserVaultPositionPoolId,
-  generateVaultPositionPoolId: () => generateVaultPositionPoolId
+// src/utils/time.ts
+var time_exports = {};
+__export(time_exports, {
+  max: () => max2,
+  now: () => now
 });
-function calculateMaxDebt(amount, oraclePrice, lltv) {
-  const ORACLE_PRICE_SCALE = 10n ** 36n;
-  const PRECISION = 10n ** 18n;
-  const collateralQuoted = amount * oraclePrice / ORACLE_PRICE_SCALE;
-  const maxDebt = collateralQuoted * lltv / PRECISION;
-  return maxDebt;
+function now() {
+  return Math.floor(Date.now() / 1e3);
 }
-function generateBalancePoolId(parameters) {
-  const { user, chainId, token } = parameters;
-  return `${user}-${chainId.toString()}-${token}-balance`.toLowerCase();
-}
-function generateAllowancePoolId(parameters) {
-  const { user, chainId, token } = parameters;
-  return `${user}-${chainId.toString()}-${token}-allowance`.toLowerCase();
-}
-function generateSellERC20CallbackPoolId(parameters) {
-  const { user, chainId, obligationId: obligationId2, token, offerHash } = parameters;
-  return `${user}-${chainId.toString()}-${obligationId2}-${token}-${offerHash}-sell_erc20_callback`.toLowerCase();
-}
-function generateObligationCollateralPoolId(parameters) {
-  const { user, chainId, obligationId: obligationId2, token } = parameters;
-  return `${user}-${chainId.toString()}-${obligationId2}-${token}-obligation-collateral`.toLowerCase();
-}
-function generateBuyVaultCallbackPoolId(parameters) {
-  const { user, chainId, vault, offerHash } = parameters;
-  return `${user}-${chainId.toString()}-${vault}-${offerHash}-${"buy_vault_v1_callback" /* BuyVaultV1Callback */}`.toLowerCase();
-}
-function generateDebtPoolId(parameters) {
-  const { user, chainId, obligationId: obligationId2 } = parameters;
-  return `${user}-${chainId.toString()}-${obligationId2}-debt`.toLowerCase();
-}
-function generateUserVaultPositionPoolId(parameters) {
-  const { user, chainId, vault } = parameters;
-  return `${user}-${chainId.toString()}-${vault}-user-vault-position`.toLowerCase();
-}
-function generateVaultPositionPoolId(parameters) {
-  const { vault, chainId, marketId } = parameters;
-  return `${vault}-${chainId.toString()}-${marketId}-vault-position`.toLowerCase();
-}
-function generateMarketLiquidityPoolId(parameters) {
-  const { chainId, marketId } = parameters;
-  return `${chainId.toString()}-${marketId}-market-liquidity`.toLowerCase();
+function max2() {
+  return 864e16;
 }
 
-// src/core/Maturity.ts
-var Maturity_exports = {};
-__export(Maturity_exports, {
-  InvalidDateError: () => InvalidDateError,
-  InvalidFormatError: () => InvalidFormatError,
-  InvalidOptionError: () => InvalidOptionError2,
-  MaturitySchema: () => MaturitySchema,
-  from: () => from3
-});
-var MaturitySchema = z6__namespace.number().int().refine(
-  (maturity) => {
-    try {
-      from3(maturity);
-      return true;
-    } catch (_e) {
-      return false;
-    }
-  },
-  {
-    error: (issue) => {
-      try {
-        const maturityDate = new Date(issue.input * 1e3);
-        return `The maturity is set to ${maturityDate}. It must fall on the allowed settlement cycles (Friday 15:00 UTC at the end of week/month/quarter).`;
-      } catch (_) {
-        return `The maturity is set to ${issue.input}. It must fall on the allowed settlement cycles (Friday 15:00 UTC at the end of week/month/quarter).`;
-      }
-    }
-  }
-).transform((maturity) => maturity);
-var MaturityOptions = {
-  end_of_week: () => endOfWeek(),
-  end_of_next_week: () => endOfNextWeek(),
-  end_of_month: () => endOfMonth(),
-  end_of_next_month: () => endOfNextMonth(),
-  end_of_quarter: () => endOfQuarter(),
-  end_of_next_quarter: () => endOfNextQuarter()
-};
-function from3(ts) {
-  if (typeof ts === "string") {
-    if (ts in MaturityOptions) return MaturityOptions[ts]();
-    throw new InvalidOptionError2(ts);
-  }
-  if (typeof ts === "number" && ts > 1e12) throw new InvalidFormatError();
-  if (!Object.values(MaturityOptions).some((option) => option() === ts))
-    throw new InvalidDateError(ts);
-  return ts;
-}
-var endOfWeek = () => fridayOfWeek(0);
-var endOfNextWeek = () => fridayOfWeek(1);
-var endOfMonth = () => lastFridayOfMonth((/* @__PURE__ */ new Date()).getUTCFullYear(), (/* @__PURE__ */ new Date()).getUTCMonth());
-var endOfNextMonth = () => lastFridayOfMonth((/* @__PURE__ */ new Date()).getUTCFullYear(), (/* @__PURE__ */ new Date()).getUTCMonth() + 1);
-var endOfQuarter = () => lastFridayOfQuarter(0);
-var endOfNextQuarter = () => lastFridayOfQuarter(1);
-var fridayOfWeek = (weeksAhead = 0) => {
-  const now2 = /* @__PURE__ */ new Date();
-  const today15H = new Date(
-    Date.UTC(now2.getUTCFullYear(), now2.getUTCMonth(), now2.getUTCDate(), 15)
-  );
-  let daysUntilFriday = (5 - today15H.getUTCDay() + 7) % 7;
-  if (daysUntilFriday === 0 && now2.getTime() >= today15H.getTime()) {
-    daysUntilFriday = 7;
-  }
-  const friday = new Date(today15H);
-  friday.setUTCDate(friday.getUTCDate() + daysUntilFriday + weeksAhead * 7);
-  return friday.getTime() / 1e3;
-};
-var lastFridayOfMonth = (year, month) => {
-  const lastDayOfMonth15H = new Date(Date.UTC(year, month + 1, 0, 15));
-  while (lastDayOfMonth15H.getUTCDay() !== 5) {
-    lastDayOfMonth15H.setUTCDate(lastDayOfMonth15H.getUTCDate() - 1);
-  }
-  const maturity = lastDayOfMonth15H.setUTCDate(lastDayOfMonth15H.getUTCDate()) / 1e3;
-  return maturity;
-};
-var lastFridayOfQuarter = (quartersAhead = 0) => {
-  const now2 = /* @__PURE__ */ new Date();
-  const quarterIndex = Math.floor(now2.getUTCMonth() / 3) + quartersAhead;
-  const year = now2.getUTCFullYear() + Math.floor(quarterIndex / 4);
-  const quarter = quarterIndex % 4;
-  const lastMonth = quarter * 3 + 2;
-  return lastFridayOfMonth(year, lastMonth);
-};
-var InvalidFormatError = class extends BaseError {
-  name = "Maturity.InvalidFormatError";
-  constructor() {
-    super("Invalid maturity format. Maturity should be expressed in seconds.");
-  }
-};
-var InvalidDateError = class extends BaseError {
-  name = "Maturity.InvalidDateError";
-  constructor(input) {
-    super(
-      `Invalid maturity date. Input: "${input}". Accepted values are: ${Object.values(
-        MaturityOptions
-      ).map((option) => `"${option()}"`).join(", ")}.`
-    );
-  }
-};
-var InvalidOptionError2 = class extends BaseError {
-  name = "Maturity.InvalidOptionError";
-  constructor(input) {
-    super(
-      `Invalid maturity option. Input: "${input}". Accepted values are: ${Object.keys(
-        MaturityOptions
-      ).map((option) => `"${option}"`).join(", ")}.`
-    );
-  }
+// src/core/Offer.ts
+var OfferHashSchema = z6__namespace.string().regex(/^0x[0-9a-fA-F]{64}$/, {
+  message: "Hash must be a valid 32-byte hex string"
+}).transform(transformHex);
+var OfferSchema = (parameters) => {
+  const { omitHash = false } = parameters || {};
+  const now2 = time_exports.now();
+  let base = z6__namespace.object({
+    offering: z6__namespace.string().transform(transformAddress),
+    assets: z6__namespace.bigint({ coerce: true }).min(0n).max(viem.maxUint256),
+    rate: z6__namespace.bigint({ coerce: true }).min(0n).max(viem.maxUint256),
+    maturity: MaturitySchema,
+    expiry: z6__namespace.number().int().min(now2, { message: "Expiry must be set to a future date" }).max(Number.MAX_SAFE_INTEGER),
+    start: z6__namespace.number().int().max(Number.MAX_SAFE_INTEGER),
+    nonce: z6__namespace.bigint({ coerce: true }).min(0n).max(viem.maxUint256),
+    buy: z6__namespace.boolean(),
+    chainId: z6__namespace.bigint({ coerce: true }).min(0n).max(viem.maxUint256),
+    loanToken: z6__namespace.string().transform(transformAddress),
+    collaterals: CollateralsSchema,
+    callback: z6__namespace.object({
+      address: z6__namespace.string().transform(transformAddress),
+      data: z6__namespace.string().transform(transformHex),
+      gasLimit: z6__namespace.bigint({ coerce: true }).min(0n).max(viem.maxUint256)
+    }),
+    consumed: z6__namespace.bigint({ coerce: true }).min(0n).max(viem.maxUint256),
+    blockNumber: z6__namespace.number().int().max(Number.MAX_SAFE_INTEGER),
+    signature: z6__namespace.string().regex(/^0x[0-9a-fA-F]{130}$/, {
+      message: "Signature must be a valid 65-byte hex string"
+    }).transform(transformHex).optional()
+  });
+  if (!omitHash) base = base.extend({ hash: OfferHashSchema });
+  return base.refine((data) => data.start < data.expiry, {
+    message: "Start must be before expiry",
+    path: ["start"]
+  }).refine((data) => data.expiry <= data.maturity, {
+    message: "Expiry cannot be after maturity",
+    path: ["expiry"]
+  });
 };
-
-// src/core/Obligation.ts
-var Obligation_exports = {};
-__export(Obligation_exports, {
-  CollateralsAreNotSortedError: () => CollateralsAreNotSortedError,
-  InvalidObligationError: () => InvalidObligationError,
-  ObligationSchema: () => ObligationSchema,
-  from: () => from4,
-  fromSnakeCase: () => fromSnakeCase2,
-  id: () => id,
-  random: () => random
-});
-var ObligationSchema = z6__namespace.object({
-  chainId: z6__namespace.bigint({ coerce: true }).min(0n).max(viem.maxUint256),
-  loanToken: z6__namespace.string().transform(transformAddress),
-  collaterals: CollateralsSchema,
-  maturity: MaturitySchema
-});
-function from4(parameters) {
+function from5(input) {
   try {
-    const parsedObligation = ObligationSchema.parse({
-      ...parameters,
-      maturity: from3(parameters.maturity)
-    });
+    const parsedOffer = OfferSchema({ omitHash: true }).parse(input);
+    const parsedHash = OfferHashSchema.parse(hash(parsedOffer));
     return {
-      chainId: parsedObligation.chainId,
-      loanToken: parsedObligation.loanToken.toLowerCase(),
-      collaterals: parsedObligation.collaterals.sort((a, b) => a.asset.localeCompare(b.asset)),
-      maturity: parsedObligation.maturity
+      ...parsedOffer,
+      hash: parsedHash
     };
   } catch (error2) {
-    throw new InvalidObligationError(error2);
+    throw new InvalidOfferError(error2);
   }
 }
-function fromSnakeCase2(input) {
-  return from4(fromSnakeCase(input));
+function fromSnakeCase3(input) {
+  return from5(fromSnakeCase(input));
 }
-function id(obligation) {
-  let lastAsset = "";
-  for (const collateral of obligation.collaterals) {
-    const newAsset = collateral.asset.toLowerCase();
-    if (newAsset.localeCompare(lastAsset) < 0) throw new CollateralsAreNotSortedError();
-    lastAsset = newAsset;
-  }
-  return viem.keccak256(
-    viem.encodeAbiParameters(
-      [
-        { type: "uint256" },
-        { type: "address" },
-        {
-          type: "tuple[]",
-          components: [
-            { type: "address", name: "token" },
-            { type: "uint256", name: "lltv" },
-            { type: "address", name: "oracle" }
-          ]
-        },
-        { type: "uint256" }
-      ],
-      [
-        obligation.chainId,
-        obligation.loanToken.toLowerCase(),
-        obligation.collaterals.map((c) => ({
-          token: c.asset.toLowerCase(),
-          lltv: c.lltv,
-          oracle: c.oracle.toLowerCase()
-        })),
-        BigInt(obligation.maturity)
-      ]
-    )
-  );
+function toSnakeCase2(offer) {
+  return toSnakeCase(offer);
 }
-function random() {
-  return from4({
-    chainId: 1n,
-    loanToken: accounts.privateKeyToAccount(accounts.generatePrivateKey()).address,
-    collaterals: [
-      from2({
-        asset: accounts.privateKeyToAccount(accounts.generatePrivateKey()).address,
-        oracle: accounts.privateKeyToAccount(accounts.generatePrivateKey()).address,
-        lltv: 0.965
-      })
-    ],
-    maturity: from3("end_of_next_quarter")
-  });
-}
-var InvalidObligationError = class extends BaseError {
-  name = "Obligation.InvalidObligationError";
-  constructor(error2) {
-    super("Invalid obligation.", { cause: error2 });
-  }
-};
-var CollateralsAreNotSortedError = class extends BaseError {
-  name = "Obligation.CollateralsAreNotSortedError";
-  constructor() {
-    super("Collaterals are not sorted alphabetically by address.");
-  }
-};
-
-// src/core/Offer.ts
-var Offer_exports = {};
-__export(Offer_exports, {
-  AccountNotSetError: () => AccountNotSetError,
-  InvalidOfferError: () => InvalidOfferError,
-  OfferHashSchema: () => OfferHashSchema,
-  OfferSchema: () => OfferSchema,
-  consumedEvent: () => consumedEvent,
-  decode: () => decode2,
-  domain: () => domain,
-  encode: () => encode2,
-  from: () => from5,
-  fromConsumedLog: () => fromConsumedLog,
-  fromSnakeCase: () => fromSnakeCase3,
-  hash: () => hash,
-  obligationId: () => obligationId,
-  random: () => random2,
-  sign: () => sign,
-  toSnakeCase: () => toSnakeCase2,
-  types: () => types
-});
-var OfferHashSchema = z6__namespace.string().regex(/^0x[0-9a-fA-F]{64}$/, {
-  message: "Hash must be a valid 32-byte hex string"
-}).transform(transformHex);
-var OfferSchema = (parameters) => {
-  const { omitHash = false } = parameters || {};
-  const now2 = time_exports.now();
-  let base = z6__namespace.object({
-    offering: z6__namespace.string().transform(transformAddress),
-    assets: z6__namespace.bigint({ coerce: true }).min(0n).max(viem.maxUint256),
-    rate: z6__namespace.bigint({ coerce: true }).min(0n).max(viem.maxUint256),
-    maturity: MaturitySchema,
-    expiry: z6__namespace.number().int().min(now2, { message: "Expiry must be set to a future date" }).max(Number.MAX_SAFE_INTEGER),
-    start: z6__namespace.number().int().max(Number.MAX_SAFE_INTEGER),
-    nonce: z6__namespace.bigint({ coerce: true }).min(0n).max(viem.maxUint256),
-    buy: z6__namespace.boolean(),
-    chainId: z6__namespace.bigint({ coerce: true }).min(0n).max(viem.maxUint256),
-    loanToken: z6__namespace.string().transform(transformAddress),
-    collaterals: CollateralsSchema,
-    callback: z6__namespace.object({
-      address: z6__namespace.string().transform(transformAddress),
-      data: z6__namespace.string().transform(transformHex),
-      gasLimit: z6__namespace.bigint({ coerce: true }).min(0n).max(viem.maxUint256)
-    }),
-    consumed: z6__namespace.bigint({ coerce: true }).min(0n).max(viem.maxUint256),
-    blockNumber: z6__namespace.number().int().max(Number.MAX_SAFE_INTEGER),
-    signature: z6__namespace.string().regex(/^0x[0-9a-fA-F]{130}$/, {
-      message: "Signature must be a valid 65-byte hex string"
-    }).transform(transformHex).optional()
-  });
-  if (!omitHash) base = base.extend({ hash: OfferHashSchema });
-  return base.refine((data) => data.start < data.expiry, {
-    message: "Start must be before expiry",
-    path: ["start"]
-  }).refine((data) => data.expiry <= data.maturity, {
-    message: "Expiry cannot be after maturity",
-    path: ["expiry"]
-  });
-};
-function from5(input) {
-  try {
-    const parsedOffer = OfferSchema({ omitHash: true }).parse(input);
-    const parsedHash = OfferHashSchema.parse(hash(parsedOffer));
-    return {
-      ...parsedOffer,
-      hash: parsedHash
-    };
-  } catch (error2) {
-    throw new InvalidOfferError(error2);
-  }
-}
-function fromSnakeCase3(input) {
-  return from5(fromSnakeCase(input));
-}
-function toSnakeCase2(offer) {
-  return toSnakeCase(offer);
-}
-function random2() {
-  const loanToken = accounts.privateKeyToAccount(accounts.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)] : accounts.privateKeyToAccount(accounts.generatePrivateKey()).address;
+  const collateralCandidates = config?.collateralTokens ? config.collateralTokens.filter((a) => a !== loanToken) : [accounts.privateKeyToAccount(accounts.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: viem.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: accounts.privateKeyToAccount(accounts.generatePrivateKey()).address,
-    assets: BigInt(Math.floor(Math.random() * 1e6)),
-    rate: BigInt(Math.floor(Math.random() * 1e6)),
+    offering: config?.offering ?? accounts.privateKeyToAccount(accounts.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: viem.zeroAddress,
+        asset: collateralAsset,
         oracle: viem.zeroAddress,
         lltv
       })
     ],
-    callback: {
-      address: viem.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: viem.zeroAddress
@@ -1864,166 +1436,1084 @@ function sign(offer, wallet) {
         gasLimit: offer.callback.gasLimit
       }
     }
-  });
+  });
+}
+function hash(offer) {
+  return viem.hashTypedData({
+    domain: domain(offer.chainId),
+    message: {
+      offering: offer.offering.toLowerCase(),
+      assets: offer.assets,
+      rate: offer.rate,
+      maturity: BigInt(offer.maturity),
+      expiry: BigInt(offer.expiry),
+      nonce: offer.nonce,
+      buy: offer.buy,
+      loanToken: offer.loanToken.toLowerCase(),
+      collaterals: offer.collaterals,
+      callback: {
+        address: offer.callback.address.toLowerCase(),
+        data: offer.callback.data,
+        gasLimit: offer.callback.gasLimit
+      }
+    },
+    primaryType: "Offer",
+    types
+  });
+}
+function obligationId(offer) {
+  return id(
+    from4({
+      chainId: offer.chainId,
+      loanToken: offer.loanToken,
+      collaterals: offer.collaterals,
+      maturity: offer.maturity
+    })
+  );
+}
+var OfferAbi = [
+  { name: "offering", type: "address" },
+  { name: "assets", type: "uint256" },
+  { name: "rate", type: "uint256" },
+  { name: "maturity", type: "uint256" },
+  { name: "expiry", type: "uint256" },
+  { name: "nonce", type: "uint256" },
+  { name: "buy", type: "bool" },
+  { name: "chainId", type: "uint256" },
+  { name: "loanToken", type: "address" },
+  { name: "start", type: "uint256" },
+  {
+    name: "collaterals",
+    type: "tuple[]",
+    components: [
+      { name: "asset", type: "address" },
+      { name: "oracle", type: "address" },
+      { name: "lltv", type: "uint256" }
+    ]
+  },
+  {
+    name: "callback",
+    type: "tuple",
+    components: [
+      { name: "address", type: "address" },
+      { name: "data", type: "bytes" },
+      { name: "gasLimit", type: "uint256" }
+    ]
+  },
+  { name: "signature", type: "bytes" }
+];
+function encode(offer) {
+  return viem.encodeAbiParameters(OfferAbi, [
+    offer.offering,
+    offer.assets,
+    offer.rate,
+    BigInt(offer.maturity),
+    BigInt(offer.expiry),
+    offer.nonce,
+    offer.buy,
+    offer.chainId,
+    offer.loanToken,
+    BigInt(offer.start),
+    offer.collaterals,
+    offer.callback,
+    offer.signature ?? "0x"
+  ]);
+}
+function decode(data, blockNumber) {
+  let decoded;
+  try {
+    decoded = viem.decodeAbiParameters(OfferAbi, data);
+  } catch (error2) {
+    throw new InvalidOfferError(error2);
+  }
+  const offer = from5({
+    offering: decoded[0],
+    assets: decoded[1],
+    rate: decoded[2],
+    maturity: from3(Number(decoded[3])),
+    expiry: Number(decoded[4]),
+    nonce: decoded[5],
+    buy: decoded[6],
+    chainId: decoded[7],
+    loanToken: decoded[8],
+    start: Number(decoded[9]),
+    collaterals: decoded[10].map((c) => {
+      return from2({
+        asset: c.asset,
+        oracle: c.oracle,
+        lltv: c.lltv
+      });
+    }),
+    callback: {
+      address: decoded[11].address,
+      data: decoded[11].data,
+      gasLimit: decoded[11].gasLimit
+    },
+    consumed: 0n,
+    blockNumber: Number(blockNumber),
+    ...decoded[12] === "0x" ? {} : { signature: decoded[12] }
+  });
+  return offer;
+}
+var consumedEvent = {
+  type: "event",
+  name: "Consumed",
+  inputs: [
+    { name: "user", type: "address", indexed: true, internalType: "address" },
+    { name: "nonce", type: "uint256", indexed: true, internalType: "uint256" },
+    { name: "amount", type: "uint256", indexed: false, internalType: "uint256" }
+  ],
+  anonymous: false
+};
+function fromConsumedLog(parameters) {
+  const { blockNumber, logIndex, chainId, transactionHash, user, nonce, amount } = parameters;
+  return {
+    id: `${blockNumber.toString()}-${logIndex.toString()}-${chainId}-${transactionHash}`,
+    chainId: BigInt(chainId),
+    offering: user,
+    nonce,
+    amount,
+    blockNumber: Number(blockNumber)
+  };
+}
+var InvalidOfferError = class extends BaseError {
+  name = "Offer.InvalidOfferError";
+  constructor(error2) {
+    super("Invalid offer.", { cause: error2 });
+  }
+};
+var AccountNotSetError = class extends BaseError {
+  name = "Offer.AccountNotSetError";
+  constructor() {
+    super("Account not set.");
+  }
+};
+
+// src/core/Quote.ts
+var Quote_exports = {};
+__export(Quote_exports, {
+  InvalidQuoteError: () => InvalidQuoteError,
+  QuoteSchema: () => QuoteSchema,
+  from: () => from6,
+  fromSnakeCase: () => fromSnakeCase4,
+  random: () => random3
+});
+var QuoteSchema = z6__namespace.object({
+  obligationId: z6__namespace.string().transform(transformHex),
+  ask: z6__namespace.object({
+    rate: z6__namespace.bigint({ coerce: true }).min(0n).max(viem.maxUint256)
+  }),
+  bid: z6__namespace.object({
+    rate: z6__namespace.bigint({ coerce: true }).min(0n).max(viem.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/core/types.ts
+var BrandTypeId = Symbol.for("mempool/Brand");
+var CollectorHealth = v4.z.object({
+  name: v4.z.string(),
+  chain_id: v4.z.number(),
+  block_number: v4.z.number().nullable(),
+  updated_at: v4.z.string().nullable(),
+  lag: v4.z.number().nullable(),
+  status: v4.z.enum(["live", "lagging", "unknown"])
+});
+var CollectorsHealthResponse = v4.z.array(CollectorHealth);
+var ChainHealth = v4.z.object({
+  chain_id: v4.z.number(),
+  block_number: v4.z.number(),
+  updated_at: v4.z.string()
+});
+var ChainsHealthResponse = v4.z.array(ChainHealth);
+var RouterStatusResponse = v4.z.object({
+  status: v4.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 jsBase64.Base64.encodeURL(JSON.stringify(c));
+}
+function decode2(token) {
+  if (!token) return null;
+  const decoded = JSON.parse(jsBase64.Base64.decode(token));
+  validate(decoded);
+  return decoded;
+}
+
+// src/api/Schema/requests.ts
+var MAX_LIMIT = 100;
+var DEFAULT_LIMIT = 20;
+var PaginationQueryParams = z6__namespace.object({
+  cursor: z6__namespace.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__namespace.string().regex(/^[1-9]\d*$/, {
+    message: "Limit must be a positive integer"
+  }).transform((val) => Number.parseInt(val, 10)).pipe(
+    z6__namespace.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__namespace.object({
+  ...PaginationQueryParams.shape,
+  side: z6__namespace.enum(["buy", "sell"]).meta({
+    description: "Side of the offer.",
+    example: "buy"
+  }),
+  obligation_id: z6__namespace.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__namespace.object({
+  ...PaginationQueryParams.shape,
+  cursor: z6__namespace.string().optional().meta({
+    description: "Obligation id cursor",
+    example: "0x1234567890123456789012345678901234567890123456789012345678901234"
+  })
+});
+var schemas = {
+  get_offers: GetOffersQueryParams,
+  get_obligations: GetObligationsQueryParams
+};
+function parse(action, query) {
+  return schemas[action].parse(query);
+}
+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 v4.z.object({
+    status: v4.z.literal("success"),
+    cursor: v4.z.string().nullable(),
+    data: v4.z.any(),
+    meta: v4.z.object({
+      timestamp: v4.z.string()
+    })
+  }).extend({
+    data: withDataMeta
+  }).meta({
+    example: {
+      status: "success",
+      cursor,
+      data: dataExample,
+      meta: { timestamp: timestampExample }
+    }
+  });
+}
+var OffersSuccessResponseSchema = makeSuccessResponse({
+  dataSchema: v4.z.array(v4.z.any()),
+  dataDescription: "Offers matching the provided filters.",
+  dataExample: [toSnakeCase(Offer_exports.random())],
+  cursor: cursorExample
+});
+var ObligationsSuccessResponseSchema = makeSuccessResponse({
+  dataSchema: v4.z.array(v4.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 = v4.z.object({
+  status: v4.z.literal("error"),
+  error: v4.z.object({
+    code: v4.z.string(),
+    message: v4.z.string(),
+    details: v4.z.any().optional()
+  }),
+  meta: v4.z.object({
+    timestamp: v4.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 = zodOpenapi.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/services/Health.ts
+var Health_exports = {};
+__export(Health_exports, {
+  create: () => create9
+});
+
+// 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/Logger.ts
+var Logger_exports = {};
+__export(Logger_exports, {
+  LogLevelValues: () => LogLevelValues,
+  defaultLogger: () => defaultLogger,
+  getLogger: () => getLogger,
+  runWithLogger: () => runWithLogger,
+  silentLogger: () => silentLogger
+});
+var LogLevelValues = [
+  "trace",
+  "debug",
+  "info",
+  "warn",
+  "error",
+  "fatal",
+  "silent"
+];
+function defaultLogger(minLevel, pretty) {
+  const threshold = minLevel ?? process.env.ROUTER_LOG_LEVEL ?? "info";
+  const prettyEnabled = typeof pretty === "boolean" ? pretty : String(process.env.ROUTER_LOG_PRETTY ?? "false").toLowerCase() === "true";
+  const levelIndexByName = LogLevelValues.reduce(
+    (acc, lvl, idx) => {
+      acc[lvl] = idx;
+      return acc;
+    },
+    {}
+  );
+  const isEnabled = (methodLevel) => levelIndexByName[methodLevel] >= levelIndexByName[threshold];
+  const wrap = (consoleMethod, methodLevel) => isEnabled(methodLevel) ? (entry) => {
+    if (!prettyEnabled) {
+      console[consoleMethod](viem.stringify({ level: methodLevel, ...entry }));
+      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 {
+    trace: wrap("trace", "trace"),
+    debug: wrap("debug", "debug"),
+    info: wrap("info", "info"),
+    warn: wrap("warn", "warn"),
+    error: wrap("error", "error"),
+    fatal: wrap("error", "fatal")
+  };
 }
-function hash(offer) {
-  return viem.hashTypedData({
-    domain: domain(offer.chainId),
-    message: {
-      offering: offer.offering.toLowerCase(),
-      assets: offer.assets,
-      rate: offer.rate,
-      maturity: BigInt(offer.maturity),
-      expiry: BigInt(offer.expiry),
-      nonce: offer.nonce,
-      buy: offer.buy,
-      loanToken: offer.loanToken.toLowerCase(),
-      collaterals: offer.collaterals,
-      callback: {
-        address: offer.callback.address.toLowerCase(),
-        data: offer.callback.data,
-        gasLimit: offer.callback.gasLimit
-      }
-    },
-    primaryType: "Offer",
-    types
-  });
+function silentLogger() {
+  const noop = () => {
+  };
+  return { trace: noop, debug: noop, info: noop, warn: noop, error: noop, fatal: noop };
 }
-function obligationId(offer) {
-  return id(
-    from4({
-      chainId: offer.chainId,
-      loanToken: offer.loanToken,
-      collaterals: offer.collaterals,
-      maturity: offer.maturity
-    })
-  );
+var loggerContext = new async_hooks.AsyncLocalStorage();
+function runWithLogger(logger, fn) {
+  return loggerContext.run(logger, fn);
 }
-var OfferAbi = [
-  { name: "offering", type: "address" },
-  { name: "assets", type: "uint256" },
-  { name: "rate", type: "uint256" },
-  { name: "maturity", type: "uint256" },
-  { name: "expiry", type: "uint256" },
-  { name: "nonce", type: "uint256" },
-  { name: "buy", type: "bool" },
-  { name: "chainId", type: "uint256" },
-  { name: "loanToken", type: "address" },
-  { name: "start", type: "uint256" },
-  {
-    name: "collaterals",
-    type: "tuple[]",
-    components: [
-      { name: "asset", type: "address" },
-      { name: "oracle", type: "address" },
-      { name: "lltv", type: "uint256" }
-    ]
-  },
-  {
-    name: "callback",
-    type: "tuple",
-    components: [
-      { name: "address", type: "address" },
-      { name: "data", type: "bytes" },
-      { name: "gasLimit", type: "uint256" }
-    ]
-  },
-  { name: "signature", type: "bytes" }
-];
-function encode2(offer) {
-  return viem.encodeAbiParameters(OfferAbi, [
-    offer.offering,
-    offer.assets,
-    offer.rate,
-    BigInt(offer.maturity),
-    BigInt(offer.expiry),
-    offer.nonce,
-    offer.buy,
-    offer.chainId,
-    offer.loanToken,
-    BigInt(offer.start),
-    offer.collaterals,
-    offer.callback,
-    offer.signature ?? "0x"
-  ]);
+function getLogger() {
+  return loggerContext.getStore() ?? defaultLogger();
 }
-function decode2(data, blockNumber) {
-  let decoded;
+function formatValue(value) {
+  if (value === null || value === void 0 || typeof value === "number" || typeof value === "bigint" || typeof value === "boolean") {
+    return String(value);
+  }
+  if (typeof value === "string") {
+    if (value.includes(" ")) return JSON.stringify(value);
+    return value;
+  }
   try {
-    decoded = viem.decodeAbiParameters(OfferAbi, data);
-  } catch (error2) {
-    throw new InvalidOfferError(error2);
+    return viem.stringify(value);
+  } catch {
+    try {
+      return JSON.stringify(value);
+    } catch {
+      return String(value);
+    }
   }
-  const offer = from5({
-    offering: decoded[0],
-    assets: decoded[1],
-    rate: decoded[2],
-    maturity: from3(Number(decoded[3])),
-    expiry: Number(decoded[4]),
-    nonce: decoded[5],
-    buy: decoded[6],
-    chainId: decoded[7],
-    loanToken: decoded[8],
-    start: Number(decoded[9]),
-    collaterals: decoded[10].map((c) => {
-      return from2({
-        asset: c.asset,
-        oracle: c.oracle,
-        lltv: c.lltv
+}
+
+// src/services/RouterAdmin.ts
+function create(parameters) {
+  const collector = "admin";
+  const {
+    client,
+    chain,
+    withTransaction,
+    options: { maxBatchSize = 25, maxBlockNumber } = {}
+  } = parameters;
+  const maxBlockNumberBI = maxBlockNumber !== void 0 ? BigInt(maxBlockNumber) : void 0;
+  let finalizedBlock = null;
+  let unfinalizedBlocks = [];
+  const logger = getLogger();
+  let isMaxBlockNumberReached = false;
+  let tick = 0;
+  return {
+    syncBlock: async () => {
+      if (isMaxBlockNumberReached) return;
+      const head = await client.getBlock({
+        blockTag: "latest",
+        includeTransactions: false
+      });
+      await withTransaction(async ({ chainStore, collectorStore }) => {
+        const { epoch, blockNumber: latestSavedBlockNumber } = await chainStore.getBlockNumber(
+          chain.id
+        );
+        if (maxBlockNumberBI !== void 0 && head.number >= maxBlockNumberBI) {
+          logger.info({
+            msg: `Head is greater than max block number`,
+            collector,
+            chainId: chain.id,
+            block_number: head.number,
+            max_block_number: maxBlockNumber
+          });
+          isMaxBlockNumberReached = true;
+          await chainStore.saveBlockNumber({
+            chainId: chain.id,
+            blockNumber: maxBlockNumber,
+            epoch: epoch + 1n
+          });
+          await Promise.all(
+            names.map(
+              async (collectorName) => collectorStore.saveBlockNumber({
+                collectorName,
+                chainId: chain.id,
+                blockNumber: maxBlockNumber,
+                epoch: epoch + 1n
+              })
+            )
+          );
+          return;
+        }
+        finalizedBlock = await fetchFinalizedBlock({
+          tick,
+          client,
+          chain,
+          logger,
+          collector,
+          unfinalizedBlocks,
+          previousFinalizedBlock: finalizedBlock
+        });
+        tick++;
+        let {
+          block: returnedBlock,
+          didReorgHappened,
+          unfinalizedBlocks: newUnfinalizedBlocks
+        } = await reconcile({
+          client,
+          block: head,
+          unfinalizedBlocks,
+          finalizedBlock,
+          logger,
+          collector,
+          chain,
+          maxBatchSize
+        });
+        unfinalizedBlocks = newUnfinalizedBlocks;
+        const blockNumber = Number(returnedBlock.number);
+        didReorgHappened = didReorgHappened || blockNumber < latestSavedBlockNumber;
+        await chainStore.saveBlockNumber({
+          chainId: chain.id,
+          blockNumber,
+          epoch: didReorgHappened ? epoch + 1n : epoch
+        });
+        if (didReorgHappened) {
+          await Promise.all(
+            names.map(
+              async (collectorName) => collectorStore.saveBlockNumber({
+                collectorName,
+                chainId: chain.id,
+                blockNumber,
+                epoch: epoch + 1n
+              })
+            )
+          );
+        }
       });
-    }),
-    callback: {
-      address: decoded[11].address,
-      data: decoded[11].data,
-      gasLimit: decoded[11].gasLimit
-    },
-    consumed: 0n,
-    blockNumber: Number(blockNumber),
-    ...decoded[12] === "0x" ? {} : { signature: decoded[12] }
-  });
-  return offer;
+    }
+  };
 }
-var consumedEvent = {
-  type: "event",
-  name: "Consumed",
-  inputs: [
-    { name: "user", type: "address", indexed: true, internalType: "address" },
-    { name: "nonce", type: "uint256", indexed: true, internalType: "uint256" },
-    { name: "amount", type: "uint256", indexed: false, internalType: "uint256" }
-  ],
-  anonymous: false
+var commonAncestor = (block, unfinalizedBlocks) => {
+  const parent = unfinalizedBlocks.find((b) => b.hash === block.parentHash);
+  if (parent) return parent;
+  return null;
 };
-function fromConsumedLog(parameters) {
-  const { blockNumber, logIndex, chainId, transactionHash, user, nonce, amount } = parameters;
+var fetchFinalizedBlock = async (parameters) => {
+  let { tick, client, chain, logger, collector, unfinalizedBlocks, previousFinalizedBlock } = parameters;
+  let finalizedBlock = previousFinalizedBlock;
+  if (tick % 20 === 0 || previousFinalizedBlock === null) {
+    finalizedBlock = await client.getBlock({
+      blockTag: "finalized",
+      includeTransactions: false
+    });
+    if (finalizedBlock === null || finalizedBlock.number === null) {
+      const msg = "Failed to get finalized block";
+      logger.fatal({ collector, chainId: chain.id, msg });
+      throw new Error(msg);
+    }
+    unfinalizedBlocks = unfinalizedBlocks.filter((b) => b.number >= finalizedBlock.number);
+  }
+  if (finalizedBlock.number === null || finalizedBlock.hash === null || finalizedBlock.parentHash === null) {
+    const msg = "Failed to get finalized block";
+    logger.fatal({ collector, chainId: chain.id, msg });
+    throw new Error(msg);
+  }
   return {
-    id: `${blockNumber.toString()}-${logIndex.toString()}-${chainId}-${transactionHash}`,
-    chainId: BigInt(chainId),
-    offering: user,
-    nonce,
-    amount,
-    blockNumber: Number(blockNumber)
+    hash: finalizedBlock.hash,
+    number: finalizedBlock.number,
+    parentHash: finalizedBlock.parentHash
   };
-}
-var InvalidOfferError = class extends BaseError {
-  name = "Offer.InvalidOfferError";
-  constructor(error2) {
-    super("Invalid offer.", { cause: error2 });
-  }
 };
-var AccountNotSetError = class extends BaseError {
-  name = "Offer.AccountNotSetError";
-  constructor() {
-    super("Account not set.");
+var reconcile = async (parameters) => {
+  let { client, block, unfinalizedBlocks, finalizedBlock, logger, collector, chain, maxBatchSize } = parameters;
+  if (block.hash === null || block.number === null || block.parentHash === null)
+    throw new Error("Failed to get block");
+  const latestBlock = unfinalizedBlocks[unfinalizedBlocks.length - 1];
+  if (latestBlock === void 0) {
+    const newBlock2 = {
+      hash: block.hash,
+      number: block.number,
+      parentHash: block.parentHash
+    };
+    unfinalizedBlocks.push(newBlock2);
+    return { block: newBlock2, didReorgHappened: false, unfinalizedBlocks };
+  }
+  if (latestBlock.hash === block.hash)
+    return { block: latestBlock, didReorgHappened: false, unfinalizedBlocks };
+  if (latestBlock.number >= block.number) {
+    const ancestor = commonAncestor(block, unfinalizedBlocks) || finalizedBlock;
+    logger.info({
+      msg: `Reorg detected`,
+      collector,
+      chain_id: chain.id,
+      ancestor: ancestor.number,
+      block_range: [latestBlock.number, block.number]
+    });
+    unfinalizedBlocks = unfinalizedBlocks.filter((b) => b.number <= ancestor.number);
+    return { block: ancestor, didReorgHappened: true, unfinalizedBlocks };
+  }
+  if (latestBlock.number + 1n < block.number) {
+    logger.debug({
+      collector,
+      chain_id: chain.id,
+      block_range: [latestBlock.number, block.number],
+      msg: `Missing blocks`
+    });
+    const missingBlockNumbers = (() => {
+      const missingBlockNumbers2 = [];
+      let start2 = latestBlock.number + 1n;
+      const threshold = latestBlock.number + BigInt(maxBatchSize) > block.number ? block.number : latestBlock.number + BigInt(maxBatchSize);
+      while (start2 < threshold) {
+        missingBlockNumbers2.push(start2);
+        start2 = start2 + 1n;
+      }
+      return missingBlockNumbers2;
+    })();
+    const missingBlocks = await Promise.all(
+      missingBlockNumbers.map(
+        (blockNumber) => retry(async () => await client.getBlock({ blockNumber, includeTransactions: false }))
+      )
+    );
+    for (const missingBlock of missingBlocks) {
+      const { block: returnedBlock, didReorgHappened } = await reconcile({
+        client,
+        block: missingBlock,
+        unfinalizedBlocks,
+        finalizedBlock,
+        logger,
+        collector,
+        chain,
+        maxBatchSize
+      });
+      if (returnedBlock.number !== missingBlock.number)
+        return { block: returnedBlock, didReorgHappened, unfinalizedBlocks };
+    }
+    return reconcile({
+      client,
+      block,
+      unfinalizedBlocks,
+      finalizedBlock,
+      logger,
+      collector,
+      chain,
+      maxBatchSize
+    });
+  }
+  if (block.parentHash !== latestBlock.hash) {
+    const ancestor = commonAncestor(block, unfinalizedBlocks) || finalizedBlock;
+    logger.info({
+      msg: `Reorg detected`,
+      collector,
+      chain_id: chain.id,
+      ancestor: ancestor.number,
+      block_range: [latestBlock.number, block.number]
+    });
+    unfinalizedBlocks = unfinalizedBlocks.filter((b) => b.number <= ancestor.number);
+    return { block: ancestor, didReorgHappened: true, unfinalizedBlocks };
   }
+  const newBlock = {
+    hash: block.hash,
+    number: block.number,
+    parentHash: block.parentHash
+  };
+  unfinalizedBlocks.push(newBlock);
+  return { block: newBlock, didReorgHappened: false, unfinalizedBlocks };
 };
 
-// src/core/types.ts
-var BrandTypeId = Symbol.for("mempool/Brand");
+// src/collectors/Collector.ts
+var names = [
+  "mempool_offers",
+  "consumed_events",
+  "buy_with_empty_callback_liquidity",
+  "buy_vault_v1_callback_liquidity",
+  "sell_erc20_callback_liquidity"
+];
+function create2({
+  name,
+  collect,
+  client,
+  chain,
+  withTransaction,
+  collectorStore,
+  options
+}) {
+  const admin = create({
+    client,
+    chain,
+    withTransaction,
+    options
+  });
+  return {
+    name,
+    chain,
+    collect: lazy((emit) => {
+      const collector = name;
+      const logger = getLogger();
+      logger.info({
+        msg: `Collector started`,
+        collector,
+        chain_id: chain.id,
+        interval: options.interval
+      });
+      return poll(
+        async () => {
+          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 }
+      );
+    })
+  };
+}
+function start(collector) {
+  let stopped = false;
+  const it = collector.collect();
+  (async () => {
+    while (!stopped) await it.next();
+    await it.return();
+  })();
+  return () => {
+    stopped = true;
+  };
+}
 
-// src/mempool/MempoolEVMClient.ts
+// src/mempool/index.ts
+var mempool_exports = {};
+__export(mempool_exports, {
+  ChainIdMismatchError: () => ChainIdMismatchError,
+  ViemClientError: () => ViemClientError,
+  WalletAccountNotSetError: () => WalletAccountNotSetError,
+  add: () => add,
+  connect: () => connect,
+  from: () => from7,
+  get: () => get,
+  watch: () => watch
+});
 var DEFAULT_BATCH_SIZE2 = 100;
 var DEFAULT_BLOCK_WINDOW2 = 100;
-function from6(parameters) {
+function from7(parameters) {
   const config = {
     client: parameters.client,
     mempoolAddress: parameters.mempoolAddress,
@@ -2165,7 +2655,7 @@ var ChainIdMismatchError = class extends BaseError {
 
 // src/mempool/MempoolClient.ts
 function connect(parameters) {
-  return from6(parameters);
+  return from7(parameters);
 }
 
 // src/services/Services.ts
@@ -2173,7 +2663,7 @@ var Services_exports = {};
 __export(Services_exports, {
   createStores: () => createStores,
   createWithTransaction: () => createWithTransaction,
-  from: () => from7
+  from: () => from8
 });
 
 // src/indexer/RouterIndexer.ts
@@ -3080,9 +3570,67 @@ function create7(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 };
+      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: drizzleOrm.sql`COALESCE(SUM(${consumed.consumed}), 0)`.as("consumed")
+      }).from(consumed).where(
+        drizzleOrm.and(
+          drizzleOrm.eq(consumed.offering, offers.offering),
+          drizzleOrm.eq(consumed.nonce, offers.nonce),
+          drizzleOrm.eq(consumed.chainId, offers.chainId)
+        )
+      ).as("sum_consumed");
+      const remaining = drizzleOrm.sql`(${offers.assets} - COALESCE(${sumConsumed.consumed}, 0))`;
+      const query = ({ side }) => db.selectDistinctOn([offers.obligationId], {
+        obligationId: offers.obligationId,
+        rate: offers.rate
+      }).from(offers).leftJoinLateral(sumConsumed, drizzleOrm.sql`true`).where(
+        drizzleOrm.and(
+          drizzleOrm.inArray(offers.obligationId, obligationIds),
+          drizzleOrm.gte(offers.expiry, now2),
+          drizzleOrm.gte(offers.maturity, now2),
+          drizzleOrm.eq(offers.buy, side === "buy"),
+          drizzleOrm.sql`${remaining} > 0`
+        )
+      ).orderBy(
+        offers.obligationId,
+        // lower rates first for buy, higher rates first for sell
+        side === "buy" ? drizzleOrm.asc(offers.rate) : drizzleOrm.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);
+      });
     }
   };
 }
@@ -3810,7 +4358,7 @@ async function clean(pg) {
 }
 
 // src/services/Services.ts
-function from7(config) {
+function from8(config) {
   const {
     chain,
     rpcUrl,
@@ -5462,7 +6010,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 {
@@ -5527,269 +6075,31 @@ async function getHealthCollectors(healthService) {
     return error(err);
   }
 }
-var CollectorHealth = v4.z.object({
-  name: v4.z.string(),
-  chain_id: v4.z.number(),
-  block_number: v4.z.number().nullable(),
-  updated_at: v4.z.string().nullable(),
-  lag: v4.z.number().nullable(),
-  status: v4.z.enum(["live", "lagging", "unknown"])
-});
-var CollectorsHealthResponse = v4.z.object({
-  collectors: v4.z.array(CollectorHealth)
-});
-var ChainHealth = v4.z.object({
-  chain_id: v4.z.number(),
-  block_number: v4.z.number(),
-  updated_at: v4.z.string()
-});
-var ChainsHealthResponse = v4.z.object({
-  chains: v4.z.array(ChainHealth)
-});
-var RouterStatusResponse = v4.z.object({
-  status: v4.z.enum(["live", "syncing"])
-});
 
-// src/api/Api/Schema/ObligationResponse.ts
+// src/api/Schema/ObligationResponse.ts
 var ObligationResponse_exports = {};
 __export(ObligationResponse_exports, {
-  from: () => from8
+  from: () => from9
 });
-function from8(obligation) {
-  return toSnakeCase({ id: Obligation_exports.id(obligation), ...obligation });
+function from9(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: () => from9
+  from: () => from10
 });
-function from9(offer) {
+function from10(offer) {
   return toSnakeCase(offer);
 }
-var MAX_LIMIT = 100;
-var DEFAULT_LIMIT = 20;
-var PaginationQueryParams = z6__namespace.object({
-  cursor: z6__namespace.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__namespace.string().regex(/^[1-9]\d*$/, {
-    message: "Limit must be a positive integer"
-  }).transform((val) => Number.parseInt(val, 10)).pipe(
-    z6__namespace.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__namespace.object({
-  ...PaginationQueryParams.shape,
-  side: z6__namespace.enum(["buy", "sell"]).meta({
-    description: "Side of the offer.",
-    example: "buy"
-  }),
-  obligation_id: z6__namespace.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__namespace.object({
-  ...PaginationQueryParams.shape,
-  cursor: z6__namespace.string().optional().meta({
-    description: "Obligation id cursor",
-    example: "0x1234567890123456789012345678901234567890123456789012345678901234"
-  })
-});
-var schemas = {
-  get_offers: GetOffersQueryParams,
-  get_obligations: GetObligationsQueryParams
-};
-function parse(action, query) {
-  return schemas[action].parse(query);
-}
-function safeParse(action, query, error2) {
-  return schemas[action].safeParse(query, {
-    error: error2
-  });
-}
-
-// src/api/Api/Schema/openapi.ts
-var successResponseSchema = v4.z.object({
-  status: v4.z.literal("success"),
-  cursor: v4.z.string().nullable(),
-  data: v4.z.array(v4.z.any()),
-  meta: v4.z.object({
-    timestamp: v4.z.string()
-  })
-});
-var errorResponseSchema = v4.z.object({
-  status: v4.z.literal("error"),
-  error: v4.z.object({
-    code: v4.z.string(),
-    message: v4.z.string(),
-    details: v4.z.any().optional()
-  }),
-  meta: v4.z.object({
-    timestamp: v4.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
-            }
-          }
-        }
-      }
-    }
-  }
-};
-var OpenApi = zodOpenapi.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);
@@ -5800,8 +6110,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) {
@@ -5815,7 +6137,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);
@@ -5843,7 +6165,7 @@ async function getOffers(queryParameters, store) {
   }
 }
 
-// src/api/Api/Api.ts
+// src/api/Api.ts
 function create8(config) {
   return {
     serve: ({ port }) => {
@@ -5875,13 +6197,20 @@ function serve(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));
   nodeServer.serve({
     fetch: app.fetch,
     port: parameters.port
   });
 }
 
-// src/api/Client.ts
+// src/client/Client.ts
 var Client_exports = {};
 __export(Client_exports, {
   HttpForbiddenError: () => HttpForbiddenError,
@@ -5936,8 +6265,16 @@ async function getObligations2(config, parameters) {
   if (parameters?.limit !== void 0) {
     url.searchParams.set("limit", parameters.limit.toString());
   }
-  const { cursor: returnedCursor, data: obligationsSnake } = await getApi(config, url);
-  const obligations2 = obligationsSnake.map(Obligation_exports.fromSnakeCase);
+  const { cursor: returnedCursor, data: items } = await getApi(config, url);
+  const obligations2 = items.map((item) => {
+    const obligation = Obligation_exports.fromSnakeCase(item);
+    const { obligationId: _, ...returned } = {
+      id: () => Obligation_exports.id(obligation),
+      ...obligation,
+      ...Quote_exports.fromSnakeCase({ obligation_id: item.id, ask: item.ask, bid: item.bid })
+    };
+    return returned;
+  });
   return {
     cursor: returnedCursor,
     obligations: obligations2
@@ -6054,7 +6391,8 @@ exports.OfferStore = OfferStore_exports;
 exports.OffersSchema = schema_exports;
 exports.OpenApi = OpenApi;
 exports.PG = PG_exports;
-exports.RouterApi = Api_exports2;
+exports.Quote = Quote_exports;
+exports.RouterApi = RouterApi_exports;
 exports.RouterClient = Client_exports;
 exports.RouterIndexer = RouterIndexer_exports;
 exports.RouterStatusResponse = RouterStatusResponse;