@morpho-dev/router 0.1.6 → 0.1.8

package/dist/index.node.mjs

@@ -1,12 +1,22 @@
-import { Errors, LLTV, Offer, Format, Time, Maturity, Utils } from '@morpho-dev/mempool';
+import { Errors, LLTV, Offer, Format, Utils, Chain, Maturity, Time, Mempool } from '@morpho-dev/mempool';
 export * from '@morpho-dev/mempool';
-import { Base64 } from 'js-base64';
 import { z } from 'zod/v4';
 import { createDocument } from 'zod-openapi';
-import { parseUnits, maxUint256, formatUnits, erc20Abi } from 'viem';
+import { parseUnits, maxUint256, publicActions, parseEventLogs, formatUnits, createWalletClient, http, erc20Abi, stringify } from 'viem';
+import { Base64 } from 'js-base64';
+import { getBlockNumber } from 'viem/actions';
+import { AsyncLocalStorage } from 'async_hooks';
+import { desc, and, eq, sql, gte, lte, asc, inArray } from 'drizzle-orm';
+import { pgSchema, timestamp, varchar, bigint, text, boolean, integer, numeric, index, serial, jsonb, uniqueIndex, primaryKey } from 'drizzle-orm/pg-core';
+import path from 'path';
+import { PGlite } from '@electric-sql/pglite';
+import { drizzle } from 'drizzle-orm/node-postgres';
+import { migrate } from 'drizzle-orm/node-postgres/migrator';
+import { drizzle as drizzle$1 } from 'drizzle-orm/pglite';
+import { migrate as migrate$1 } from 'drizzle-orm/pglite/migrator';
+import { Pool } from 'pg';
 import { serve as serve$1 } from '@hono/node-server';
 import { Hono } from 'hono';
-import { AsyncLocalStorage } from 'async_hooks';
 
 var __defProp = Object.defineProperty;
 var __export = (target, all) => {
@@ -14,60 +24,17 @@ var __export = (target, all) => {
     __defProp(target, name, { get: all[name], enumerable: true });
 };
 
-// src/Callback.ts
-var Callback_exports = {};
-__export(Callback_exports, {
-  CallbackType: () => CallbackType,
-  buildLiquidity: () => buildLiquidity,
-  getCallbackIdForOffer: () => getCallbackIdForOffer
+// src/core/apiSchema/index.ts
+var apiSchema_exports = {};
+__export(apiSchema_exports, {
+  OpenApi: () => OpenApi,
+  fromResponse: () => fromResponse,
+  parse: () => parse,
+  safeParse: () => safeParse,
+  toResponse: () => toResponse
 });
-var CallbackType = /* @__PURE__ */ ((CallbackType2) => {
-  CallbackType2["BuyWithEmptyCallback"] = "buy_with_empty_callback";
-  return CallbackType2;
-})(CallbackType || {});
-function buildLiquidity(parameters) {
-  const { type, user, contract, chainId, amount, index = 0, updatedAt = /* @__PURE__ */ new Date() } = parameters;
-  if (type !== "buy_with_empty_callback" /* BuyWithEmptyCallback */)
-    throw new Error(`CallbackType not implemented: ${type}`);
-  const amountStr = amount.toString();
-  const id = `${user}-${chainId.toString()}-${type}-${contract}`.toLowerCase();
-  return {
-    userPosition: {
-      id,
-      availableLiquidityQueueId: id,
-      user: user.toLowerCase(),
-      chainId,
-      amount: amountStr,
-      updatedAt
-    },
-    queues: [
-      {
-        queue: {
-          queueId: id,
-          availableLiquidityPoolId: id,
-          index,
-          updatedAt
-        },
-        pool: {
-          id,
-          amount: amountStr,
-          updatedAt
-        }
-      }
-    ]
-  };
-}
-function getCallbackIdForOffer(offer) {
-  if (offer.buy && offer.callback.data === "0x") {
-    const type = "buy_with_empty_callback" /* BuyWithEmptyCallback */;
-    const user = offer.offering;
-    const loanToken = offer.loanToken;
-    return `${user}-${offer.chainId.toString()}-${type}-${loanToken}`.toLowerCase();
-  }
-  return null;
-}
 
-// src/Cursor.ts
+// src/core/Cursor.ts
 var Cursor_exports = {};
 __export(Cursor_exports, {
   decode: () => decode,
@@ -153,17 +120,7 @@ function decode(token) {
   return decoded;
 }
 
-// src/core/apiSchema/index.ts
-var apiSchema_exports = {};
-__export(apiSchema_exports, {
-  OpenApi: () => OpenApi,
-  fromResponse: () => fromResponse,
-  parse: () => parse,
-  safeParse: () => safeParse,
-  toResponse: () => toResponse
-});
-
-// src/RouterOffer.ts
+// src/core/RouterOffer.ts
 var RouterOffer_exports = {};
 __export(RouterOffer_exports, {
   InvalidRouterOfferError: () => InvalidRouterOfferError,
@@ -740,513 +697,1586 @@ var OpenApi = createDocument({
 
 // src/core/apiSchema/utils.ts
 function toResponse(routerOffer) {
-  const { consumed, status, metadata, ...offer } = routerOffer;
+  const { consumed: consumed2, status, metadata, ...offer } = routerOffer;
   return {
     offer,
-    consumed,
+    consumed: consumed2,
     status,
     metadata
   };
 }
 function fromResponse(offerResponse) {
-  const { offer, consumed, status, metadata } = offerResponse;
+  const { offer, consumed: consumed2, status, metadata } = offerResponse;
   return {
     ...offer,
-    consumed,
+    consumed: consumed2,
     status,
     metadata
   };
 }
 
-// src/core/router/index.ts
-var router_exports = {};
-__export(router_exports, {
-  APIError: () => APIError,
-  BadRequestError: () => BadRequestError,
-  HttpForbiddenError: () => HttpForbiddenError,
-  HttpGetOffersFailedError: () => HttpGetOffersFailedError,
-  HttpRateLimitError: () => HttpRateLimitError,
-  HttpUnauthorizedError: () => HttpUnauthorizedError,
-  InternalServerError: () => InternalServerError,
-  InvalidUrlError: () => InvalidUrlError,
-  NotFoundError: () => NotFoundError,
-  ValidationError: () => ValidationError,
-  connect: () => connect,
-  error: () => error,
-  get: () => get,
-  handleZodError: () => handleZodError,
-  match: () => match,
-  serve: () => serve,
-  success: () => success
+// src/core/Callback.ts
+var Callback_exports = {};
+__export(Callback_exports, {
+  CallbackType: () => CallbackType,
+  buildLiquidity: () => buildLiquidity,
+  getCallbackIdForOffer: () => getCallbackIdForOffer
 });
-function connect(opts) {
-  const u = new URL(opts?.url || "https://router.morpho.dev");
-  if (u.protocol !== "http:" && u.protocol !== "https:") {
-    throw new InvalidUrlError(u.toString());
-  }
-  const headers = opts?.headers ?? new Headers();
-  headers.set("Content-Type", "application/json");
-  opts?.apiKey !== void 0 ? headers.set("X-API-Key", opts.apiKey) : null;
-  const config = {
-    url: u,
-    headers
-  };
+var CallbackType = /* @__PURE__ */ ((CallbackType2) => {
+  CallbackType2["BuyWithEmptyCallback"] = "buy_with_empty_callback";
+  return CallbackType2;
+})(CallbackType || {});
+function buildLiquidity(parameters) {
+  const { type, user, contract, chainId, amount, index: index2 = 0, updatedAt = /* @__PURE__ */ new Date() } = parameters;
+  if (type !== "buy_with_empty_callback" /* BuyWithEmptyCallback */)
+    throw new Error(`CallbackType not implemented: ${type}`);
+  const amountStr = amount.toString();
+  const id = `${user}-${chainId.toString()}-${type}-${contract}`.toLowerCase();
   return {
-    ...config,
-    get: (parameters) => get(config, parameters),
-    match: (parameters) => match(config, parameters)
+    userPosition: {
+      id,
+      availableLiquidityQueueId: id,
+      user: user.toLowerCase(),
+      chainId,
+      amount: amountStr,
+      updatedAt
+    },
+    queues: [
+      {
+        queue: {
+          queueId: id,
+          availableLiquidityPoolId: id,
+          index: index2,
+          updatedAt
+        },
+        pool: {
+          id,
+          amount: amountStr,
+          updatedAt
+        }
+      }
+    ]
   };
 }
-async function get(config, parameters) {
-  const url = new URL(`${config.url.toString()}v1/offers`);
-  if (parameters.creators?.length) {
-    url.searchParams.set("creators", parameters.creators.join(","));
-  }
-  if (parameters.side) {
-    url.searchParams.set("side", parameters.side);
-  }
-  if (parameters.chains?.length) {
-    url.searchParams.set("chains", parameters.chains.join(","));
-  }
-  if (parameters.loanTokens?.length) {
-    url.searchParams.set("loan_tokens", parameters.loanTokens.join(","));
+function getCallbackIdForOffer(offer) {
+  if (offer.buy && offer.callback.data === "0x") {
+    const type = "buy_with_empty_callback" /* BuyWithEmptyCallback */;
+    const user = offer.offering;
+    const loanToken = offer.loanToken;
+    return `${user}-${offer.chainId.toString()}-${type}-${loanToken}`.toLowerCase();
   }
-  if (parameters.status?.length) {
-    url.searchParams.set("status", parameters.status.join(","));
+  return null;
+}
+
+// src/core/Collector/index.ts
+var Collector_exports = {};
+__export(Collector_exports, {
+  createBuyWithEmptyCallbackLiquidityCollector: () => createBuyWithEmptyCallbackLiquidityCollector,
+  createChainReorgsCollector: () => createChainReorgsCollector,
+  createConsumedEventsCollector: () => createConsumedEventsCollector,
+  createMempoolCollector: () => createMempoolCollector,
+  start: () => start
+});
+
+// src/core/Liquidity.ts
+var Liquidity_exports = {};
+__export(Liquidity_exports, {
+  fetch: () => fetch2,
+  fetchBalancesAndAllowances: () => fetchBalancesAndAllowances,
+  serialize: () => serialize
+});
+async function fetchBalancesAndAllowances(parameters) {
+  const { client, spender, pairs, options } = parameters;
+  if (pairs.length === 0) return /* @__PURE__ */ new Map();
+  const batchSize = Math.max(1, options?.batchSize ?? 5e3);
+  const retryAttempts = Math.max(1, options?.retryAttempts ?? 3);
+  const retryDelayMs = Math.max(0, options?.retryDelayMs ?? 50);
+  const blockNumber = options?.blockNumber ? BigInt(options.blockNumber) : void 0;
+  const out = /* @__PURE__ */ new Map();
+  for (const pairsBatch of Utils.batch(pairs, batchSize)) {
+    const balanceContracts = [];
+    const allowanceContracts = [];
+    for (const { user, token } of pairsBatch) {
+      balanceContracts.push({
+        address: token,
+        abi: erc20Abi,
+        functionName: "balanceOf",
+        args: [user]
+      });
+      allowanceContracts.push({
+        address: token,
+        abi: erc20Abi,
+        functionName: "allowance",
+        args: [user, spender]
+      });
+    }
+    const [balances, allowances] = await Promise.all([
+      Utils.retry(
+        () => client.multicall({
+          allowFailure: false,
+          contracts: balanceContracts,
+          ...blockNumber ? { blockNumber } : {}
+        }),
+        retryAttempts,
+        retryDelayMs
+      ),
+      Utils.retry(
+        () => client.multicall({
+          allowFailure: false,
+          contracts: allowanceContracts,
+          ...blockNumber ? { blockNumber } : {}
+        }),
+        retryAttempts,
+        retryDelayMs
+      )
+    ]);
+    for (let i = 0; i < pairsBatch.length; i++) {
+      const { user, token } = pairsBatch[i];
+      const balance = balances[i];
+      const allowance = allowances[i];
+      let perUser = out.get(user);
+      if (!perUser) {
+        perUser = /* @__PURE__ */ new Map();
+        out.set(user, perUser);
+      }
+      perUser.set(token, { balance, allowance });
+    }
   }
-  if (parameters.callbackAddresses?.length) {
-    url.searchParams.set("callback_addresses", parameters.callbackAddresses.join(","));
+  return out;
+}
+async function fetch2(parameters) {
+  const { client, chainId, spender, type, pairs, options } = parameters;
+  if (type !== "buy_with_empty_callback" /* BuyWithEmptyCallback */)
+    throw new Error(`CallbackType not implemented: ${type}`);
+  const map = await fetchBalancesAndAllowances({
+    client,
+    spender,
+    pairs: pairs.map(({ user, contract }) => ({ user, token: contract })),
+    options
+  });
+  const out = [];
+  for (const [user, perContract] of map) {
+    for (const [contract, { balance, allowance }] of perContract) {
+      const amount = balance < allowance ? balance : allowance;
+      out.push(
+        buildLiquidity({
+          type,
+          user,
+          contract,
+          chainId,
+          amount: amount.toString(),
+          index: 0
+        })
+      );
+    }
   }
-  if (parameters.minAmount !== void 0) {
-    url.searchParams.set("min_amount", parameters.minAmount.toString());
-  }
-  if (parameters.maxAmount !== void 0) {
-    url.searchParams.set("max_amount", parameters.maxAmount.toString());
-  }
-  if (parameters.minRate !== void 0) {
-    url.searchParams.set("min_rate", parameters.minRate.toString());
-  }
-  if (parameters.maxRate !== void 0) {
-    url.searchParams.set("max_rate", parameters.maxRate.toString());
-  }
-  if (parameters.minMaturity !== void 0) {
-    url.searchParams.set("min_maturity", parameters.minMaturity.toString());
-  }
-  if (parameters.maxMaturity !== void 0) {
-    url.searchParams.set("max_maturity", parameters.maxMaturity.toString());
-  }
-  if (parameters.minExpiry !== void 0) {
-    url.searchParams.set("min_expiry", parameters.minExpiry.toString());
-  }
-  if (parameters.maxExpiry !== void 0) {
-    url.searchParams.set("max_expiry", parameters.maxExpiry.toString());
-  }
-  if (parameters.collateralAssets?.length) {
-    url.searchParams.set("collateral_assets", parameters.collateralAssets.join(","));
-  }
-  if (parameters.collateralOracles?.length) {
-    url.searchParams.set("collateral_oracles", parameters.collateralOracles.join(","));
-  }
-  if (parameters.collateralTuple?.length) {
-    const tupleStr = parameters.collateralTuple.map(({ asset, oracle, lltv }) => {
-      let result = asset;
-      if (oracle) {
-        result += `:${oracle}`;
-      } else if (lltv !== void 0) {
-        result += `:`;
+  return out;
+}
+function serialize(liquidity) {
+  const normalized = {
+    userPosition: {
+      id: liquidity.userPosition.id,
+      availableLiquidityQueueId: liquidity.userPosition.availableLiquidityQueueId,
+      user: liquidity.userPosition.user,
+      chainId: String(liquidity.userPosition.chainId),
+      amount: String(liquidity.userPosition.amount)
+    },
+    queues: liquidity.queues.map((queueWithPool) => ({
+      queue: {
+        queueId: queueWithPool.queue.queueId,
+        availableLiquidityPoolId: queueWithPool.queue.availableLiquidityPoolId,
+        index: queueWithPool.queue.index
+      },
+      pool: {
+        id: queueWithPool.pool.id,
+        amount: String(queueWithPool.pool.amount)
       }
-      if (lltv !== void 0) result += `:${formatUnits(lltv, 16)}`;
-      return result;
-    }).join("#");
-    url.searchParams.set("collateral_tuple", tupleStr);
-  }
-  if (parameters.minLltv !== void 0) {
-    url.searchParams.set("min_lltv", formatUnits(parameters.minLltv, 16));
-  }
-  if (parameters.maxLltv !== void 0) {
-    url.searchParams.set("max_lltv", formatUnits(parameters.maxLltv, 16));
-  }
-  if (parameters.sortBy) {
-    url.searchParams.set("sort_by", parameters.sortBy);
-  }
-  if (parameters.sortOrder) {
-    url.searchParams.set("sort_order", parameters.sortOrder);
-  }
-  if (parameters.cursor) {
-    url.searchParams.set("cursor", parameters.cursor);
-  }
-  if (parameters.limit !== void 0) {
-    url.searchParams.set("limit", parameters.limit.toString());
-  }
-  const { cursor: returnedCursor, data: offers } = await getApi(config, url);
-  const routerOffers = offers.map(Format.fromSnakeCase).map(fromResponse);
-  return {
-    cursor: returnedCursor,
-    offers: routerOffers.map(from).map(toResponse)
+    })).sort(
+      (left, right) => {
+        const leftQueueId = left.queue.queueId || "";
+        const rightQueueId = right.queue.queueId || "";
+        if (leftQueueId < rightQueueId) return -1;
+        if (leftQueueId > rightQueueId) return 1;
+        const leftPoolId = left.pool.id;
+        const rightPoolId = right.pool.id;
+        if (leftPoolId < rightPoolId) return -1;
+        if (leftPoolId > rightPoolId) return 1;
+        const leftIndex = left.queue.index;
+        const rightIndex = right.queue.index;
+        if (leftIndex < rightIndex) return -1;
+        if (leftIndex > rightIndex) return 1;
+        return 0;
+      }
+    )
   };
+  return JSON.stringify(normalized);
 }
-async function match(config, parameters) {
-  const url = new URL(`${config.url.toString()}v1/offers/match`);
-  url.searchParams.set("side", parameters.side);
-  url.searchParams.set("chain_id", parameters.chainId.toString());
-  if (parameters.rate !== void 0) {
-    url.searchParams.set("rate", parameters.rate.toString());
-  }
-  if (parameters.collaterals?.length) {
-    const collateralsStr = parameters.collaterals.map(({ asset, oracle, lltv }) => `${asset}:${oracle}:${formatUnits(lltv, 16)}`).join("#");
-    url.searchParams.set("collaterals", collateralsStr);
-  }
-  if (parameters.maturity !== void 0) {
-    url.searchParams.set("maturity", parameters.maturity.toString());
-  }
-  if (parameters.minMaturity !== void 0) {
-    url.searchParams.set("min_maturity", parameters.minMaturity.toString());
-  }
-  if (parameters.maxMaturity !== void 0) {
-    url.searchParams.set("max_maturity", parameters.maxMaturity.toString());
-  }
-  if (parameters.loanToken) {
-    url.searchParams.set("loan_token", parameters.loanToken);
-  }
-  if (parameters.creator) {
-    url.searchParams.set("creator", parameters.creator);
-  }
-  if (parameters.status?.length) {
-    url.searchParams.set("status", parameters.status.join(","));
-  }
-  if (parameters.cursor) {
-    url.searchParams.set("cursor", parameters.cursor);
-  }
-  if (parameters.limit !== void 0) {
-    url.searchParams.set("limit", parameters.limit.toString());
-  }
-  const { cursor: returnedCursor, data: offers } = await getApi(config, url);
-  const routerOffers = offers.map(Format.fromSnakeCase).map(fromResponse);
+
+// src/core/Logger.ts
+var Logger_exports = {};
+__export(Logger_exports, {
+  LogLevelValues: () => LogLevelValues,
+  defaultLogger: () => defaultLogger,
+  getLogger: () => getLogger,
+  runWithLogger: () => runWithLogger,
+  silentLogger: () => silentLogger
+});
+var LogLevelValues = [
+  "silent",
+  "trace",
+  "debug",
+  "info",
+  "warn",
+  "error",
+  "fatal"
+];
+function defaultLogger(minLevel) {
+  const threshold = minLevel ?? "info";
+  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) => {
+    console[consoleMethod](stringify({ level: methodLevel, ...entry }));
+  } : () => {
+  };
   return {
-    cursor: returnedCursor,
-    offers: routerOffers.map(from).map(toResponse)
+    trace: wrap("trace", "trace"),
+    debug: wrap("debug", "debug"),
+    info: wrap("info", "info"),
+    warn: wrap("warn", "warn"),
+    error: wrap("error", "error"),
+    fatal: wrap("error", "fatal")
   };
 }
-async function getApi(config, url) {
-  const pathname = url.pathname;
-  let action;
-  switch (true) {
-    case pathname.includes("/v1/offers/match"):
-      action = "match_offers";
-      break;
-    case pathname.includes("/v1/offers"):
-      action = "get_offers";
-      break;
-    default:
-      throw new HttpGetOffersFailedError("Unknown endpoint", {
-        details: `Unsupported path: ${pathname}`
+function silentLogger() {
+  const noop = () => {
+  };
+  return { trace: noop, debug: noop, info: noop, warn: noop, error: noop, fatal: noop };
+}
+var loggerContext = new AsyncLocalStorage();
+function runWithLogger(logger, fn) {
+  return loggerContext.run(logger, fn);
+}
+function getLogger() {
+  return loggerContext.getStore() ?? defaultLogger();
+}
+
+// src/core/Collector/BuyWithEmptyCallbackLiquidityCollector.ts
+function createBuyWithEmptyCallbackLiquidityCollector(params) {
+  const {
+    client,
+    collectorBlockStore,
+    liquidityStore,
+    offerStore,
+    chain,
+    options: { maxBatchSize = 1e3, interval = 3e4 } = {}
+  } = params;
+  const collector = "buy_with_empty_callback_liquidity";
+  async function getUniqueUserTokenPairs() {
+    const unique = /* @__PURE__ */ new Set();
+    const pairs = [];
+    let cursor;
+    do {
+      const { offers: offers2, nextCursor } = await offerStore.getAll({
+        query: {
+          side: "buy",
+          chains: [Number(chain.id)],
+          cursor,
+          limit: 1e3
+        }
       });
-  }
-  const schemaParseResult = safeParse(action, Object.fromEntries(url.searchParams));
-  if (!schemaParseResult.success) {
-    throw new HttpGetOffersFailedError(`Invalid URL parameters`, {
-      details: schemaParseResult.error.issues[0]?.message
+      cursor = nextCursor ?? void 0;
+      for (const offer of offers2) {
+        const creator = offer.offering;
+        const loanToken = offer.loanToken;
+        const key = `${offer.offering}-${offer.loanToken}`.toLowerCase();
+        if (unique.has(key)) continue;
+        unique.add(key);
+        pairs.push({ user: creator, token: loanToken });
+      }
+    } while (cursor);
+    return pairs;
+  }
+  const collect = Utils.lazy((emit) => {
+    const logger = getLogger();
+    logger.info({
+      collector,
+      chainId: chain.id,
+      msg: "start",
+      interval,
+      maxBatchSize
     });
-  }
-  const response = await fetch(url.toString(), {
-    method: "GET",
-    headers: config.headers
+    return Utils.poll(
+      async () => {
+        const publicClient = client.extend(publicActions);
+        const pairs = await getUniqueUserTokenPairs();
+        const latestBlockNumber = Number(await getBlockNumber(publicClient));
+        logger.debug({
+          collector,
+          chainId: chain.id,
+          msg: "snapshot started",
+          blockNumber: latestBlockNumber
+        });
+        const liquidityEntries = await fetch2({
+          client: publicClient,
+          chainId: chain.id,
+          spender: chain.morpho,
+          type: "buy_with_empty_callback" /* BuyWithEmptyCallback */,
+          pairs: pairs.map(({ user, token }) => ({ user, contract: token })),
+          options: {
+            blockNumber: latestBlockNumber,
+            batchSize: maxBatchSize
+          }
+        });
+        logger.debug({
+          collector,
+          chainId: chain.id,
+          msg: `found ${liquidityEntries.length} liquidity entries`,
+          blockNumber: latestBlockNumber
+        });
+        const existingLiquidityEntries = await liquidityStore.getAll();
+        const existingById = /* @__PURE__ */ new Map();
+        for (const liquidityEntry of existingLiquidityEntries) {
+          const liquidityId = liquidityEntry.userPosition.id;
+          const serializedEntry = serialize(liquidityEntry);
+          existingById.set(liquidityId, serializedEntry);
+        }
+        for (const liquidity of liquidityEntries) {
+          const serialized = serialize(liquidity);
+          const prevSerialized = existingById.get(liquidity.userPosition.id);
+          if (prevSerialized === serialized) continue;
+          await liquidityStore.save({ liquidity });
+        }
+        await collectorBlockStore.saveBlockNumber({
+          collectorName: collector,
+          chainId: chain.id,
+          blockNumber: latestBlockNumber
+        });
+        logger.info({
+          collector,
+          chainId: chain.id,
+          msg: "snapshot done",
+          blockNumber: latestBlockNumber
+        });
+        emit(latestBlockNumber);
+      },
+      { interval }
+    );
   });
-  if (!response.ok) {
-    switch (response.status) {
-      case 401:
-        throw new HttpUnauthorizedError();
-      case 403:
-        throw new HttpForbiddenError();
-      case 429:
-        throw new HttpRateLimitError();
+  const onReorg = (_lastFinalizedBlockNumber) => {
+  };
+  return {
+    name: collector,
+    lastSyncedBlock: async () => await collectorBlockStore.getBlockNumber({ collectorName: collector, chainId: chain.id }),
+    collect,
+    onReorg
+  };
+}
+function createChainReorgsCollector(parameters) {
+  const collectorName = "chain_reorgs";
+  const {
+    client,
+    subscribers,
+    collectorStore,
+    chain,
+    options: { maxBatchSize = 25, interval } = {}
+  } = parameters;
+  let finalizedBlock = null;
+  let unfinalizedBlocks = [];
+  const commonAncestor = (block) => {
+    const parent = unfinalizedBlocks.find((b) => b.hash === block.parentHash);
+    if (parent) return parent;
+    if (finalizedBlock == null) throw new Error("Failed to get common ancestor");
+    return finalizedBlock;
+  };
+  const reconcile = async (block) => {
+    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) {
+      unfinalizedBlocks.push({
+        hash: block.hash,
+        number: block.number,
+        parentHash: block.parentHash
+      });
+      return;
     }
-    throw new HttpGetOffersFailedError(`GET request returned ${response.status}`, {
-      details: await response.text()
+    if (latestBlock.hash === block.hash) return;
+    if (latestBlock.number >= block.number) {
+      const ancestor = commonAncestor(block);
+      console.log(
+        `reorg detected, latestBlock.number: ${latestBlock.number} > block.number: ${block.number} on chain ${chain.id}. Ancestor: ${ancestor.number}`
+      );
+      subscribers.forEach((subscriber) => subscriber.onReorg(Number(ancestor.number)));
+      unfinalizedBlocks = [];
+      return;
+    }
+    if (latestBlock.number + 1n < block.number) {
+      console.log(
+        `missing blocks between block ${latestBlock.number} and block ${block.number} on chain ${chain.id}`
+      );
+      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) => client.getBlock({ blockNumber, includeTransactions: false })
+        )
+      );
+      for (const missingBlock of missingBlocks) await reconcile(missingBlock);
+      await reconcile(block);
+      return;
+    }
+    if (block.parentHash !== latestBlock.hash) {
+      const ancestor = commonAncestor(block);
+      console.log(
+        `reorg detected, block.parentHash: ${block.parentHash} !== latestBlock.hash: ${latestBlock.hash} on chain ${chain.id}. Ancestor: ${ancestor.number}`
+      );
+      subscribers.forEach((subscriber) => subscriber.onReorg(Number(ancestor.number)));
+      unfinalizedBlocks = [];
+      return;
+    }
+    unfinalizedBlocks.push({
+      hash: block.hash,
+      number: block.number,
+      parentHash: block.parentHash
     });
-  }
-  return response.json();
+  };
+  const collect = Utils.lazy((emit) => {
+    let tick = 0;
+    const fetchFinalizedBlock = async () => {
+      if (tick % 20 === 0 || finalizedBlock === null) {
+        finalizedBlock = await client.getBlock({
+          blockTag: "finalized",
+          includeTransactions: false
+        });
+        if (finalizedBlock === null) throw new Error("Failed to get finalized block");
+      }
+      tick++;
+    };
+    return Utils.poll(
+      async () => {
+        await fetchFinalizedBlock();
+        const latestBlock = await client.getBlock({
+          blockTag: "latest",
+          includeTransactions: false
+        });
+        await reconcile(latestBlock);
+        const lastBlockNumber = Number(latestBlock.number);
+        await collectorStore.saveBlockNumber({
+          collectorName: "chain_reorgs",
+          chainId: chain.id,
+          blockNumber: lastBlockNumber
+        });
+        emit(lastBlockNumber);
+      },
+      { interval: interval ?? 3e4 }
+    );
+  });
+  return {
+    name: collectorName,
+    lastSyncedBlock: async () => await collectorStore.getBlockNumber({ collectorName, chainId: chain.id }),
+    collect,
+    onReorg: (_) => {
+    }
+  };
 }
-var InvalidUrlError = class extends Errors.BaseError {
-  name = "Router.InvalidUrlError";
-  constructor(url) {
-    super(`URL "${url}" is not http/https.`);
-  }
-};
-var HttpUnauthorizedError = class extends Errors.BaseError {
-  name = "Router.HttpUnauthorizedError";
-  constructor() {
-    super("Unauthorized.", {
-      metaMessages: ["Ensure that an API key is provided."]
-    });
-  }
-};
-var HttpForbiddenError = class extends Errors.BaseError {
-  name = "Router.HttpForbiddenError";
-  constructor() {
-    super("Forbidden.", {
-      metaMessages: ["Ensure that the API key is valid."]
+
+// src/core/Collector/Collector.ts
+function start(collector) {
+  let stopped = false;
+  const it = collector.collect();
+  (async () => {
+    while (!stopped) await it.next();
+    await it.return();
+  })();
+  return () => {
+    stopped = true;
+  };
+}
+function createConsumedEventsCollector(parameters) {
+  const {
+    client,
+    contractAddress,
+    offerStore,
+    collectorBlockStore,
+    options: { maxBatchSize = 1e3, interval = 3e4 } = {},
+    chainId
+  } = parameters;
+  const collector = "consumed_events";
+  const collect = Utils.lazy((emit) => {
+    const logger = getLogger();
+    logger.info({
+      collector,
+      chainId: chainId.toString(),
+      msg: "start",
+      interval,
+      maxBatchSize
     });
+    return Utils.poll(
+      async () => {
+        const lastSyncedBlock = await collectorBlockStore.getBlockNumber({
+          collectorName: collector,
+          chainId
+        });
+        logger.debug({ collector, chainId, msg: "stream started", blockNumber: lastSyncedBlock });
+        const stream = Chain.streamLogs({
+          client,
+          contractAddress,
+          event: consumedEvent,
+          blockNumberGte: lastSyncedBlock,
+          order: "asc",
+          options: { maxBatchSize }
+        });
+        let blockNumber = lastSyncedBlock;
+        for await (const { logs, blockNumber: lastStreamBlockNumber } of stream) {
+          try {
+            const parsedLogs = parseEventLogs({ abi: [consumedEvent], logs });
+            logger.debug({ collector, chainId, msg: `found ${parsedLogs.length} consumed events` });
+            for (const log of parsedLogs) {
+              if (log.blockNumber === null || log.logIndex === null || log.transactionHash === null) {
+                logger.debug({
+                  collector,
+                  chainId,
+                  msg: "skipping log because it is missing required fields"
+                });
+                continue;
+              }
+              const offer = fromConsumedLog({
+                blockNumber: log.blockNumber,
+                logIndex: log.logIndex,
+                chainId: Number(chainId),
+                transactionHash: log.transactionHash,
+                user: log.args.user,
+                nonce: log.args.nonce,
+                amount: log.args.amount
+              });
+              await offerStore.updateConsumedAmount({
+                id: offer.id,
+                chainId: offer.chainId,
+                offering: offer.offering,
+                nonce: offer.nonce,
+                consumed: offer.amount
+              });
+            }
+            blockNumber = lastStreamBlockNumber;
+            await collectorBlockStore.saveBlockNumber({
+              collectorName: collector,
+              chainId,
+              blockNumber
+            });
+            emit(blockNumber);
+          } catch (err) {
+            logger.error({ err, msg: "Failed to process offer_consumed events" });
+          }
+        }
+        logger.info({
+          collector,
+          chainId,
+          msg: "stream finished",
+          startBlock: lastSyncedBlock,
+          endBlock: blockNumber
+        });
+      },
+      { interval }
+    );
+  });
+  const onReorg = (_lastFinalizedBlockNumber) => {
+  };
+  return {
+    name: collector,
+    lastSyncedBlock: async () => await collectorBlockStore.getBlockNumber({ collectorName: collector, chainId }),
+    onReorg,
+    collect
+  };
+}
+
+// src/core/Validation.ts
+var Validation_exports = {};
+__export(Validation_exports, {
+  run: () => run
+});
+async function run(parameters) {
+  const { items, rules, ctx = {}, chunkSize } = parameters;
+  const issues = [];
+  let validItems = items.slice();
+  for (const rule of rules) {
+    if (validItems.length === 0) return { valid: [], issues };
+    const indicesToRemove = /* @__PURE__ */ new Set();
+    if (rule.kind === "single") {
+      for (let i = 0; i < validItems.length; i++) {
+        const item = validItems[i];
+        const issue = await rule.run(item, ctx);
+        if (issue) {
+          issues.push({ ...issue, ruleName: rule.name, item });
+          indicesToRemove.add(i);
+        }
+      }
+    } else if (rule.kind === "batch") {
+      const exec = async (slice, offset) => {
+        const map = await rule.run(slice, ctx);
+        for (let i = 0; i < slice.length; i++) {
+          const issue = map.get(i);
+          if (issue !== void 0) {
+            issues.push({ ...issue, ruleName: rule.name, item: slice[i] });
+            indicesToRemove.add(offset + i);
+          }
+        }
+      };
+      if (!chunkSize) await exec(validItems, 0);
+      else {
+        for (let i = 0; i < validItems.length; i += chunkSize) {
+          await exec(validItems.slice(i, i + chunkSize), i);
+        }
+      }
+    }
+    validItems = validItems.filter((_, i) => !indicesToRemove.has(i));
   }
-};
-var HttpRateLimitError = class extends Errors.BaseError {
-  name = "Router.HttpRateLimitError";
-  constructor() {
-    super("Rate limit exceeded.", {
-      metaMessages: [
-        "The number of allowed requests has been exceeded. You must wait for the rate limit to reset."
-      ]
+  return {
+    valid: validItems,
+    issues
+  };
+}
+
+// src/core/ValidationRule.ts
+var ValidationRule_exports = {};
+__export(ValidationRule_exports, {
+  batch: () => batch,
+  morpho: () => morpho,
+  single: () => single
+});
+function single(name, run2) {
+  return { kind: "single", name, run: run2 };
+}
+function batch(name, run2) {
+  return { kind: "batch", name, run: run2 };
+}
+function morpho() {
+  const chainId = single("chain_id", (offer, { chain }) => {
+    if (chain.id !== offer.chainId) {
+      return {
+        message: `Chain ID ${offer.chainId} is not the same as the chain ID in the context (${chain.id})`
+      };
+    }
+  });
+  const loanToken = single("loan_token", (offer, { chain }) => {
+    const tokens = new Set(
+      Array.from(chain.whitelistedAssets.values()).map((a) => a.toLowerCase())
+    );
+    if (!tokens.has(offer.loanToken.toLowerCase())) {
+      return {
+        message: `Loan token ${offer.loanToken} is not whitelisted on chain ${offer.chainId}`
+      };
+    }
+  });
+  const expiry = single("expiry", (offer, _) => {
+    if (offer.expiry < Math.floor(Date.now() / 1e3)) {
+      return { message: "Expiry mismatch" };
+    }
+  });
+  const callback = single("empty_callback", (offer, _) => {
+    if (!offer.buy || offer.callback.data !== "0x") {
+      return { message: "Callback not supported yet." };
+    }
+  });
+  return [
+    chainId,
+    loanToken,
+    expiry,
+    // note: callback rule should be the last one, since it does not mean that the offer is forever invalid
+    // integrators should be able to choose if they want to keep the offer or not
+    callback
+  ];
+}
+
+// src/core/Collector/MempoolCollector.ts
+function createMempoolCollector(parameters) {
+  const {
+    mempool,
+    offerStore,
+    collectorBlockStore,
+    chain,
+    options: { maxBatchSize = 1e3, interval = 3e4 } = {}
+  } = parameters;
+  const collector = "mempool_offers";
+  const collect = Utils.lazy((emit) => {
+    const logger = getLogger();
+    logger.info({
+      collector,
+      chainId: chain.id,
+      msg: "start",
+      interval,
+      maxBatchSize
     });
-  }
-};
-var HttpGetOffersFailedError = class extends Errors.BaseError {
-  name = "Router.HttpGetOffersFailedError";
-  constructor(message, { details } = {}) {
-    super(message, {
-      metaMessages: [details]
+    let lastSyncedBlock = null;
+    return mempool.watch({
+      lastSyncedBlock: async () => {
+        lastSyncedBlock = await collectorBlockStore.getBlockNumber({
+          collectorName: collector,
+          chainId: chain.id
+        });
+        logger.debug({
+          collector,
+          chainId: chain.id,
+          msg: "stream started",
+          blockNumber: lastSyncedBlock
+        });
+        return lastSyncedBlock;
+      },
+      polling: { maxBatchSize, interval },
+      onOffers: async (offers2, blockNumber) => {
+        logger.debug({ collector, chainId: chain.id, msg: `found ${offers2.length} offers` });
+        try {
+          const { valid: validOffers, issues } = await run({
+            items: offers2,
+            rules: morpho(),
+            ctx: { chain }
+          });
+          const invalidOffersToSave = [];
+          const issueToStatus = {
+            empty_callback: "callback_not_supported",
+            sell_offers_empty_callback: "callback_not_supported",
+            buy_offers_empty_callback: "callback_error"
+          };
+          for (const issue of issues) {
+            const status = issueToStatus[issue.ruleName];
+            if (status) {
+              invalidOffersToSave.push({
+                offer: issue.item,
+                status,
+                metadata: { issue: issue.ruleName }
+              });
+            }
+          }
+          await offerStore.createMany([
+            ...validOffers.map((offer) => ({
+              offer,
+              status: "valid"
+            })),
+            ...invalidOffersToSave
+          ]);
+        } catch (err) {
+          logger.error({
+            err,
+            msg: "Failed to process offer_created events, falling back to unverified status"
+          });
+          await offerStore.createMany(
+            offers2.map((offer) => ({
+              offer,
+              status: "unverified",
+              metadata: { issue: "Offer processing failed" }
+            }))
+          );
+        }
+        await collectorBlockStore.saveBlockNumber({
+          collectorName: collector,
+          chainId: chain.id,
+          blockNumber
+        });
+        emit(blockNumber);
+        if (lastSyncedBlock === null) return;
+        logger.info({
+          collector,
+          chainId: chain.id,
+          msg: "stream finished",
+          startBlock: lastSyncedBlock,
+          endBlock: blockNumber
+        });
+      }
     });
-  }
-};
+  });
+  const onReorg = (_lastFinalizedBlockNumber) => {
+  };
+  return {
+    name: collector,
+    lastSyncedBlock: async () => await collectorBlockStore.getBlockNumber({ collectorName: collector, chainId: chain.id }),
+    collect,
+    onReorg
+  };
+}
 
-// src/OfferStore/index.ts
-var OfferStore_exports = {};
-__export(OfferStore_exports, {
+// src/core/CollectorBlockStore.ts
+var CollectorBlockStore_exports = {};
+__export(CollectorBlockStore_exports, {
+  create: () => create,
   memory: () => memory
 });
-function memory(parameters) {
-  const map = parameters.offers;
-  const filled = parameters.filled;
-  const consumedIds = /* @__PURE__ */ new Set();
-  const create = async (parameters2) => {
-    if (map.has(parameters2.offer.hash.toLowerCase())) return parameters2.offer.hash;
-    const callbackId = getCallbackIdForOffer(parameters2.offer);
-    map.set(parameters2.offer.hash.toLowerCase(), {
-      ...parameters2.offer,
-      ...callbackId ? { callbackId } : {},
-      status: parameters2.status,
-      metadata: parameters2.metadata
-    });
-    const chainId = parameters2.offer.chainId;
-    const address = parameters2.offer.offering.toLowerCase();
-    const nonce = parameters2.offer.nonce;
-    const filledForChain = filled.get(chainId) || /* @__PURE__ */ new Map();
-    const filledForOffering = filledForChain.get(address) || /* @__PURE__ */ new Map();
-    if (!filledForOffering.has(nonce)) filledForOffering.set(nonce, 0n);
-    filledForChain.set(address, filledForOffering);
-    filled.set(chainId, filledForChain);
-    return Promise.resolve(parameters2.offer.hash);
+
+// src/core/OfferStore/drizzle/schema.ts
+var schema_exports = {};
+__export(schema_exports, {
+  VERSION: () => VERSION,
+  availableLiquidityPools: () => availableLiquidityPools,
+  availableLiquidityQueues: () => availableLiquidityQueues,
+  collectorBlockNumbers: () => collectorBlockNumbers,
+  consumed: () => consumed,
+  offerCollaterals: () => offerCollaterals,
+  offerStatus: () => offerStatus,
+  offers: () => offers,
+  userPositions: () => userPositions
+});
+var VERSION = "offers_v1.1";
+var s = pgSchema(VERSION);
+var offers = s.table(
+  "offers",
+  {
+    hash: varchar("hash", { length: 66 }).primaryKey(),
+    offering: varchar("offering", { length: 42 }).notNull(),
+    assets: numeric("assets", { precision: 78, scale: 0 }).notNull(),
+    rate: bigint("rate", { mode: "bigint" }).notNull(),
+    maturity: integer("maturity").notNull(),
+    expiry: integer("expiry").notNull(),
+    start: integer("start").notNull(),
+    nonce: bigint("nonce", { mode: "bigint" }).notNull(),
+    buy: boolean("buy").notNull(),
+    chainId: bigint("chain_id", { mode: "bigint" }).notNull(),
+    loanToken: varchar("loan_token", { length: 42 }).notNull(),
+    callbackAddress: varchar("callback_address", { length: 42 }).notNull(),
+    callbackData: text("callback_data").notNull(),
+    callbackGasLimit: bigint("callback_gas_limit", { mode: "bigint" }).notNull(),
+    signature: varchar("signature", { length: 132 }),
+    callbackId: varchar("callback_id", { length: 256 }),
+    createdAt: timestamp("created_at").defaultNow().notNull()
+  },
+  (table) => [
+    index("offers_offering_idx").on(table.offering),
+    index("offers_buy_idx").on(table.buy),
+    index("offers_chain_id_idx").on(table.chainId),
+    index("offers_loan_token_idx").on(table.loanToken),
+    index("offers_maturity_idx").on(table.maturity),
+    index("offers_expiry_idx").on(table.expiry),
+    index("offers_rate_idx").on(table.rate),
+    index("offers_assets_idx").on(table.assets),
+    // Compound indices for cursor pagination with hash
+    index("offers_rate_hash_idx").on(table.rate, table.hash),
+    index("offers_maturity_hash_idx").on(table.maturity, table.hash),
+    index("offers_expiry_hash_idx").on(table.expiry, table.hash),
+    index("offers_assets_hash_idx").on(table.assets, table.hash)
+  ]
+);
+var offerCollaterals = s.table(
+  "offer_collaterals",
+  {
+    id: serial("id").primaryKey(),
+    offerHash: varchar("offer_hash", { length: 66 }).notNull().references(() => offers.hash, { onDelete: "cascade" }),
+    asset: varchar("asset", { length: 42 }).notNull(),
+    oracle: varchar("oracle", { length: 42 }).notNull(),
+    lltv: bigint("lltv", { mode: "bigint" }).notNull()
+  },
+  (table) => [
+    index("offer_collaterals_offer_hash_idx").on(table.offerHash),
+    index("offer_collaterals_asset_idx").on(table.asset),
+    index("offer_collaterals_oracle_idx").on(table.oracle),
+    // Composite index
+    index("offer_collaterals_tuple_idx").on(table.asset, table.oracle, table.lltv)
+  ]
+);
+var offerStatus = s.table(
+  "offer_status",
+  {
+    id: serial("id").primaryKey(),
+    offerHash: varchar("offer_hash", { length: 66 }).notNull().references(() => offers.hash, { onDelete: "cascade" }),
+    status: text("status").$type().notNull(),
+    metadata: jsonb("metadata"),
+    createdAt: timestamp("created_at").defaultNow().notNull()
+  },
+  (table) => [
+    index("offer_status_offer_hash_created_at_idx").on(table.offerHash, desc(table.createdAt)),
+    index("offer_status_status_idx").on(table.status)
+  ]
+);
+var consumed = s.table(
+  "consumed_per_user_and_nonce",
+  {
+    id: varchar("id", { length: 255 }).primaryKey(),
+    chainId: bigint("chain_id", { mode: "bigint" }).notNull(),
+    offering: varchar("offering", { length: 42 }).notNull(),
+    nonce: bigint("nonce", { mode: "bigint" }).notNull(),
+    consumed: numeric("consumed", { precision: 78, scale: 0 }).notNull(),
+    createdAt: timestamp("created_at").defaultNow().notNull()
+  },
+  (table) => [
+    index("consumed_per_user_and_nonce_chain_id_offering_nonce_created_at_idx").on(
+      table.chainId,
+      table.offering,
+      table.nonce,
+      desc(table.createdAt)
+    )
+  ]
+);
+var collectorBlockNumbers = s.table(
+  "collector_block_numbers",
+  {
+    chainId: bigint("chain_id", { mode: "bigint" }).notNull(),
+    name: text("name").notNull(),
+    blockNumber: bigint("block_number", { mode: "number" }).notNull(),
+    updatedAt: timestamp("updated_at").defaultNow().notNull()
+  },
+  (table) => [uniqueIndex("collector_block_numbers_chain_name_idx").on(table.chainId, table.name)]
+);
+var availableLiquidityPools = s.table("available_liquidity_pools", {
+  id: varchar("id", { length: 255 }).primaryKey(),
+  amount: numeric("amount", { precision: 78, scale: 0 }).notNull(),
+  updatedAt: timestamp("updated_at").defaultNow().notNull()
+});
+var availableLiquidityQueues = s.table(
+  "available_liquidity_queues",
+  {
+    queueId: varchar("queue_id", { length: 255 }).notNull(),
+    availableLiquidityPoolId: varchar("available_liquidity_pool_id", { length: 255 }).notNull().references(() => availableLiquidityPools.id, { onDelete: "cascade" }),
+    index: integer("index").notNull(),
+    updatedAt: timestamp("updated_at").defaultNow().notNull()
+  },
+  (table) => [
+    primaryKey({
+      columns: [table.queueId, table.availableLiquidityPoolId],
+      name: "available_liquidity_queues_pk"
+    }),
+    index("available_liquidity_queues_queue_index_idx").on(table.queueId, table.index)
+  ]
+);
+var userPositions = s.table(
+  "user_positions",
+  {
+    id: varchar("id", { length: 255 }).primaryKey(),
+    availableLiquidityQueueId: varchar("available_liquidity_queue_id", { length: 255 }).notNull(),
+    user: varchar("user", { length: 255 }).notNull(),
+    chainId: bigint("chain_id", { mode: "bigint" }).notNull(),
+    amount: numeric("amount", { precision: 78, scale: 0 }).notNull(),
+    updatedAt: timestamp("updated_at").defaultNow().notNull()
+  },
+  (table) => [
+    index("user_positions_available_liquidity_queue_id_idx").on(table.availableLiquidityQueueId)
+  ]
+);
+
+// src/core/CollectorBlockStore.ts
+var create = (config) => {
+  const db = config.db;
+  return {
+    getBlockNumber: async (parameters) => {
+      const name = parameters.collectorName.toLowerCase();
+      const result = await db.select({ blockNumber: collectorBlockNumbers.blockNumber }).from(collectorBlockNumbers).where(
+        and(
+          eq(collectorBlockNumbers.name, name),
+          eq(collectorBlockNumbers.chainId, parameters.chainId)
+        )
+      ).limit(1);
+      if (result.length === 0)
+        return Chain.getChain(parameters.chainId)?.mempool.deploymentBlock || 0;
+      return Number(result[0].blockNumber);
+    },
+    saveBlockNumber: async (parameters) => {
+      const name = parameters.collectorName.toLowerCase();
+      await db.insert(collectorBlockNumbers).values({
+        chainId: parameters.chainId,
+        name,
+        blockNumber: parameters.blockNumber,
+        updatedAt: /* @__PURE__ */ new Date()
+      }).onConflictDoUpdate({
+        target: [collectorBlockNumbers.chainId, collectorBlockNumbers.name],
+        set: {
+          blockNumber: parameters.blockNumber,
+          updatedAt: /* @__PURE__ */ new Date()
+        }
+      });
+    }
   };
-  const sort = (sortBy, sortOrder, a, b) => {
-    sortBy = sortBy || "expiry";
-    sortOrder = sortOrder || "desc";
-    const sortKey = sortBy === "amount" ? "assets" : sortBy;
-    if (a[sortKey] === b[sortKey]) {
-      if (a.hash === b.hash) return 0;
-      return sortOrder === "asc" ? a.hash > b.hash ? 1 : -1 : b.hash > a.hash ? 1 : -1;
+};
+function memory() {
+  const blockNumbers = /* @__PURE__ */ new Map();
+  return {
+    getBlockNumber: async (parameters) => {
+      const name = parameters.collectorName.toLowerCase();
+      return blockNumbers.get(name)?.get(parameters.chainId) || Chain.getChain(parameters.chainId)?.mempool.deploymentBlock || 0;
+    },
+    saveBlockNumber: async (parameters) => {
+      const name = parameters.collectorName.toLowerCase();
+      if (!blockNumbers.has(name)) {
+        blockNumbers.set(name, /* @__PURE__ */ new Map());
+      }
+      if (!blockNumbers.get(name)?.has(parameters.chainId)) {
+        blockNumbers.get(name).set(parameters.chainId, parameters.blockNumber);
+      }
+      blockNumbers.get(name).set(parameters.chainId, parameters.blockNumber);
     }
-    switch (sortBy) {
-      case "rate":
-        if (a.rate === b.rate) {
-          if (a.hash === b.hash) return 0;
-          return sortOrder === "asc" ? a.hash > b.hash ? 1 : -1 : a.hash > b.hash ? -1 : 1;
-        }
-        return sortOrder === "asc" ? a.rate > b.rate ? 1 : -1 : b.rate > a.rate ? 1 : -1;
-      case "maturity":
-        if (a.maturity === b.maturity) {
-          if (a.hash === b.hash) return 0;
-          return sortOrder === "asc" ? a.hash > b.hash ? 1 : -1 : a.hash > b.hash ? -1 : 1;
+  };
+}
+
+// src/core/LiquidityStore.ts
+var LiquidityStore_exports = {};
+__export(LiquidityStore_exports, {
+  create: () => create2,
+  memory: () => memory2
+});
+var create2 = (config) => {
+  const db = config.db;
+  return {
+    getByUserPositionId: async (parameters) => {
+      const up = await db.select().from(userPositions).where(eq(userPositions.id, parameters.userPositionId)).limit(1);
+      if (up.length === 0) return null;
+      const userPositionRow = up[0];
+      const rows = await db.select({ queue: availableLiquidityQueues, pool: availableLiquidityPools }).from(availableLiquidityQueues).innerJoin(
+        availableLiquidityPools,
+        eq(availableLiquidityPools.id, availableLiquidityQueues.availableLiquidityPoolId)
+      ).where(eq(availableLiquidityQueues.queueId, userPositionRow.availableLiquidityQueueId));
+      const queues = rows.map((row) => ({
+        queue: row.queue,
+        pool: row.pool
+      }));
+      return { userPosition: userPositionRow, queues };
+    },
+    getAll: async () => {
+      const rows = await db.select({
+        userPosition: userPositions,
+        queue: availableLiquidityQueues,
+        pool: availableLiquidityPools
+      }).from(userPositions).innerJoin(
+        availableLiquidityQueues,
+        eq(availableLiquidityQueues.queueId, userPositions.availableLiquidityQueueId)
+      ).innerJoin(
+        availableLiquidityPools,
+        eq(availableLiquidityPools.id, availableLiquidityQueues.availableLiquidityPoolId)
+      );
+      const byUserPosition = /* @__PURE__ */ new Map();
+      for (const row of rows) {
+        const id = row.userPosition.id;
+        if (!byUserPosition.has(id)) {
+          byUserPosition.set(id, { userPosition: row.userPosition, queues: [] });
         }
-        return sortOrder === "asc" ? a.maturity > b.maturity ? 1 : -1 : b.maturity > a.maturity ? 1 : -1;
-      case "expiry":
-        if (a.expiry === b.expiry) {
-          if (a.hash === b.hash) return 0;
-          return sortOrder === "asc" ? a.hash > b.hash ? 1 : -1 : a.hash > b.hash ? -1 : 1;
+        byUserPosition.get(id).queues.push({ queue: row.queue, pool: row.pool });
+      }
+      return Array.from(byUserPosition.values());
+    },
+    save: async (parameters) => {
+      const { liquidity } = parameters;
+      await db.transaction(async (tx) => {
+        for (const qp of liquidity.queues) {
+          await tx.insert(availableLiquidityPools).values({
+            id: qp.pool.id,
+            amount: qp.pool.amount,
+            updatedAt: /* @__PURE__ */ new Date()
+          }).onConflictDoUpdate({
+            target: availableLiquidityPools.id,
+            set: {
+              amount: qp.pool.amount,
+              updatedAt: /* @__PURE__ */ new Date()
+            }
+          });
         }
-        return sortOrder === "asc" ? a.expiry > b.expiry ? 1 : -1 : b.expiry > a.expiry ? 1 : -1;
-      case "amount":
-        if (a.assets === b.assets) {
-          if (a.hash === b.hash) return 0;
-          return sortOrder === "asc" ? a.hash > b.hash ? 1 : -1 : a.hash > b.hash ? -1 : 1;
+        for (const qp of liquidity.queues) {
+          await tx.insert(availableLiquidityQueues).values({
+            queueId: qp.queue.queueId,
+            availableLiquidityPoolId: qp.pool.id,
+            index: qp.queue.index,
+            updatedAt: /* @__PURE__ */ new Date()
+          }).onConflictDoUpdate({
+            target: [
+              availableLiquidityQueues.queueId,
+              availableLiquidityQueues.availableLiquidityPoolId
+            ],
+            set: {
+              index: qp.queue.index,
+              updatedAt: /* @__PURE__ */ new Date()
+            }
+          });
         }
-        return sortOrder === "asc" ? a.assets > b.assets ? 1 : -1 : b.assets > a.assets ? 1 : -1;
-      default:
-        if (a.expiry === b.expiry) {
-          if (a.hash === b.hash) return 0;
-          return sortOrder === "asc" ? a.hash > b.hash ? 1 : -1 : a.hash > b.hash ? -1 : 1;
+        await tx.insert(userPositions).values({
+          id: liquidity.userPosition.id,
+          availableLiquidityQueueId: liquidity.userPosition.availableLiquidityQueueId,
+          user: liquidity.userPosition.user,
+          chainId: liquidity.userPosition.chainId,
+          amount: liquidity.userPosition.amount,
+          updatedAt: /* @__PURE__ */ new Date()
+        }).onConflictDoUpdate({
+          target: userPositions.id,
+          set: {
+            availableLiquidityQueueId: liquidity.userPosition.availableLiquidityQueueId,
+            user: liquidity.userPosition.user,
+            chainId: liquidity.userPosition.chainId,
+            amount: liquidity.userPosition.amount,
+            updatedAt: /* @__PURE__ */ new Date()
+          }
+        });
+      });
+    }
+  };
+};
+function memory2() {
+  const poolsById = /* @__PURE__ */ new Map();
+  const queuesByComposite = /* @__PURE__ */ new Map();
+  const queueIndexByQueueId = /* @__PURE__ */ new Map();
+  const userPositionsById = /* @__PURE__ */ new Map();
+  return {
+    getByUserPositionId: async (parameters) => {
+      const up = userPositionsById.get(parameters.userPositionId);
+      if (!up) return null;
+      const compositeKeys = queueIndexByQueueId.get(up.availableLiquidityQueueId) || /* @__PURE__ */ new Set();
+      const queues = [];
+      for (const key of compositeKeys) {
+        const q = queuesByComposite.get(key);
+        if (!q) continue;
+        const p = poolsById.get(q.availableLiquidityPoolId);
+        if (!p) continue;
+        queues.push({ queue: q, pool: p });
+      }
+      return { userPosition: up, queues };
+    },
+    getAll: async () => {
+      const results = [];
+      for (const up of userPositionsById.values()) {
+        const compositeKeys = queueIndexByQueueId.get(up.availableLiquidityQueueId) || /* @__PURE__ */ new Set();
+        const queues = [];
+        for (const key of compositeKeys) {
+          const q = queuesByComposite.get(key);
+          if (!q) continue;
+          const p = poolsById.get(q.availableLiquidityPoolId);
+          if (!p) continue;
+          queues.push({ queue: q, pool: p });
         }
-        return sortOrder === "asc" ? a.expiry > b.expiry ? 1 : -1 : b.expiry > a.expiry ? 1 : -1;
+        results.push({ userPosition: up, queues });
+      }
+      return results;
+    },
+    save: async (parameters) => {
+      const { liquidity } = parameters;
+      for (const qp of liquidity.queues) {
+        poolsById.set(qp.pool.id, {
+          id: qp.pool.id,
+          amount: qp.pool.amount,
+          updatedAt: /* @__PURE__ */ new Date()
+        });
+      }
+      for (const qp of liquidity.queues) {
+        const qid = qp.queue.queueId;
+        if (!qid) continue;
+        const composite = `${qid}::${qp.pool.id}`;
+        queuesByComposite.set(composite, {
+          queueId: qid,
+          availableLiquidityPoolId: qp.pool.id,
+          index: qp.queue.index,
+          updatedAt: /* @__PURE__ */ new Date()
+        });
+        if (!queueIndexByQueueId.has(qid)) queueIndexByQueueId.set(qid, /* @__PURE__ */ new Set());
+        queueIndexByQueueId.get(qid).add(composite);
+      }
+      userPositionsById.set(liquidity.userPosition.id, {
+        id: liquidity.userPosition.id,
+        availableLiquidityQueueId: liquidity.userPosition.availableLiquidityQueueId,
+        user: liquidity.userPosition.user,
+        chainId: liquidity.userPosition.chainId,
+        amount: liquidity.userPosition.amount,
+        updatedAt: /* @__PURE__ */ new Date()
+      });
     }
   };
+}
+
+// src/core/OfferStore/index.ts
+var OfferStore_exports = {};
+__export(OfferStore_exports, {
+  create: () => create3
+});
+function create3(config) {
+  const db = config.db;
   return {
-    create,
-    createMany: async (parameters2) => {
-      return Promise.all(
-        parameters2.map((p) => create({ offer: p.offer, status: p.status, metadata: p.metadata }))
-      );
+    create: async (parameters) => {
+      const { offer, status, metadata } = parameters;
+      return await db.transaction(async (tx) => {
+        const callbackId = getCallbackIdForOffer(offer);
+        const result = await tx.insert(offers).values({
+          hash: offer.hash.toLowerCase(),
+          offering: offer.offering.toLowerCase(),
+          assets: offer.assets.toString(),
+          rate: offer.rate,
+          maturity: offer.maturity,
+          expiry: offer.expiry,
+          start: offer.start,
+          nonce: offer.nonce,
+          buy: offer.buy,
+          chainId: offer.chainId,
+          loanToken: offer.loanToken.toLowerCase(),
+          callbackAddress: offer.callback.address.toLowerCase(),
+          callbackData: offer.callback.data,
+          callbackGasLimit: offer.callback.gasLimit,
+          signature: offer.signature,
+          callbackId: callbackId ?? null
+        }).onConflictDoNothing().returning();
+        if (result.length === 0) {
+          return offer.hash;
+        }
+        for (const collateral of offer.collaterals) {
+          await tx.insert(offerCollaterals).values({
+            offerHash: offer.hash.toLowerCase(),
+            asset: collateral.asset.toLowerCase(),
+            oracle: collateral.oracle.toLowerCase(),
+            lltv: collateral.lltv
+          });
+        }
+        await tx.insert(offerStatus).values({
+          offerHash: offer.hash.toLowerCase(),
+          status,
+          metadata
+        });
+        return offer.hash;
+      });
+    },
+    createMany: async (parameters) => {
+      return await db.transaction(async (tx) => {
+        const hashes = [];
+        for (const { offer, status, metadata } of parameters) {
+          const callbackId = getCallbackIdForOffer(offer);
+          const result = await tx.insert(offers).values({
+            hash: offer.hash.toLowerCase(),
+            offering: offer.offering.toLowerCase(),
+            assets: offer.assets.toString(),
+            rate: offer.rate,
+            maturity: offer.maturity,
+            expiry: offer.expiry,
+            start: offer.start,
+            nonce: offer.nonce,
+            buy: offer.buy,
+            chainId: offer.chainId,
+            loanToken: offer.loanToken.toLowerCase(),
+            callbackAddress: offer.callback.address.toLowerCase(),
+            callbackData: offer.callback.data,
+            callbackGasLimit: offer.callback.gasLimit,
+            signature: offer.signature,
+            callbackId: callbackId ?? null
+          }).onConflictDoNothing().returning();
+          if (result.length === 0) continue;
+          for (const collateral of offer.collaterals) {
+            await tx.insert(offerCollaterals).values({
+              offerHash: offer.hash.toLowerCase(),
+              asset: collateral.asset.toLowerCase(),
+              oracle: collateral.oracle.toLowerCase(),
+              lltv: collateral.lltv
+            });
+          }
+          await tx.insert(offerStatus).values({
+            offerHash: offer.hash.toLowerCase(),
+            status,
+            metadata
+          });
+          hashes.push(offer.hash);
+        }
+        return hashes;
+      });
     },
     getAll: async (params) => {
-      const { query } = params || {};
-      let {
-        creators,
-        side,
-        chains,
-        loanTokens,
-        status = ["valid"],
-        callbackAddresses,
-        minAmount,
-        maxAmount,
-        minRate,
-        maxRate,
-        minMaturity,
-        maxMaturity,
-        minExpiry,
-        maxExpiry,
-        collateralAssets,
-        collateralOracles,
-        collateralTuple,
-        minLltv,
-        maxLltv,
-        sortBy = "expiry",
-        sortOrder = "desc",
-        cursor: queryCursor,
-        limit = 20
-      } = query || {};
+      const { query } = params ?? {};
+      const conditions = [];
       const now = Time.now();
-      const buy = side === "buy";
-      let offers = Array.from(map.values()).map((o) => ({
-        ...o,
-        consumed: filled.get(o.chainId)?.get(o.offering.toLowerCase())?.get(o.nonce) || 0n
-      })).filter((o) => o.consumed < o.assets);
-      const cursor = decode(queryCursor);
-      if (cursor) {
-        if (cursor.sort !== sortBy || cursor.dir !== sortOrder) {
-          throw new Error("Cursor does not match the current sort parameters");
+      if (query?.creators && query.creators.length > 0) {
+        conditions.push(
+          inArray(
+            offers.offering,
+            query.creators.map((c) => c.toLowerCase())
+          )
+        );
+      }
+      if (query?.side) {
+        conditions.push(eq(offers.buy, query.side === "buy"));
+      }
+      if (query?.chains && query.chains.length > 0) {
+        conditions.push(
+          inArray(
+            offers.chainId,
+            query.chains.map((chain) => BigInt(chain))
+          )
+        );
+      }
+      if (query?.loanTokens && query.loanTokens.length > 0) {
+        conditions.push(
+          inArray(
+            offers.loanToken,
+            query.loanTokens.map((t) => t.toLowerCase())
+          )
+        );
+      }
+      if (query?.callbackAddresses && query.callbackAddresses.length > 0) {
+        conditions.push(
+          inArray(
+            offers.callbackAddress,
+            query.callbackAddresses.map((c) => c.toLowerCase())
+          )
+        );
+      }
+      conditions.push(gte(offers.expiry, now));
+      if (query?.minAmount !== void 0) {
+        conditions.push(gte(offers.assets, query.minAmount.toString()));
+      }
+      if (query?.maxAmount !== void 0) {
+        conditions.push(lte(offers.assets, query.maxAmount.toString()));
+      }
+      if (query?.minRate !== void 0) {
+        conditions.push(gte(offers.rate, query.minRate));
+      }
+      if (query?.maxRate !== void 0) {
+        conditions.push(lte(offers.rate, query.maxRate));
+      }
+      if (query?.minMaturity !== void 0) {
+        conditions.push(gte(offers.maturity, query.minMaturity));
+      }
+      if (query?.maxMaturity !== void 0) {
+        conditions.push(lte(offers.maturity, query.maxMaturity));
+      }
+      if (query?.minExpiry !== void 0) {
+        conditions.push(gte(offers.expiry, query.minExpiry));
+      }
+      if (query?.maxExpiry !== void 0) {
+        conditions.push(lte(offers.expiry, query.maxExpiry));
+      }
+      if (query?.collateralAssets && query.collateralAssets.length > 0) {
+        conditions.push(
+          inArray(
+            offerCollaterals.asset,
+            query.collateralAssets.map((a) => a.toLowerCase())
+          )
+        );
+      }
+      if (query?.collateralOracles && query.collateralOracles.length > 0) {
+        conditions.push(
+          inArray(
+            offerCollaterals.oracle,
+            query.collateralOracles.map((o) => o.toLowerCase())
+          )
+        );
+      }
+      if (query?.collateralTuple && query.collateralTuple.length > 0) {
+        const tupleClauses = query.collateralTuple.map((tuple) => {
+          const parts = [
+            sql`${offerCollaterals.asset} = ${tuple.asset.toLowerCase()}`
+          ];
+          if (tuple.oracle) {
+            parts.push(sql`${offerCollaterals.oracle} = ${tuple.oracle.toLowerCase()}`);
+          }
+          if (tuple.lltv !== void 0) {
+            parts.push(sql`${offerCollaterals.lltv} = ${tuple.lltv}`);
+          }
+          let clause = parts[0];
+          for (let i = 1; i < parts.length; i++) {
+            clause = sql`${clause} AND ${parts[i]}`;
+          }
+          return sql`(${clause})`;
+        }).filter((c) => c !== void 0);
+        if (tupleClauses.length > 0) {
+          let combined = tupleClauses[0];
+          for (let i = 1; i < tupleClauses.length; i++) {
+            combined = sql`${combined} OR ${tupleClauses[i]}`;
+          }
+          conditions.push(sql`(${combined})`);
         }
-        switch (cursor.sort) {
+      }
+      if (query?.minLltv !== void 0) {
+        conditions.push(gte(offerCollaterals.lltv, parseUnits(query.minLltv.toString(), 16)));
+      }
+      if (query?.maxLltv !== void 0) {
+        conditions.push(lte(offerCollaterals.lltv, parseUnits(query.maxLltv.toString(), 16)));
+      }
+      const sortBy = query?.sortBy ?? "expiry";
+      const sortOrder = query?.sortOrder ?? "desc";
+      const sortColumn = (() => {
+        switch (sortBy) {
           case "rate":
-            offers = offers.filter(
-              (o) => (sortOrder === "asc" ? o.rate >= BigInt(cursor.rate) : o.rate <= BigInt(cursor.rate)) && (o.rate !== BigInt(cursor.rate) || (sortOrder === "asc" ? o.hash > cursor.hash : o.hash < cursor.hash))
-            );
-            break;
+            return offers.rate;
           case "maturity":
-            offers = offers.filter(
-              (o) => (sortOrder === "asc" ? o.maturity >= BigInt(cursor.maturity) : o.maturity <= BigInt(cursor.maturity)) && (o.maturity !== Maturity.from(cursor.maturity) || (sortOrder === "asc" ? o.hash > cursor.hash : o.hash < cursor.hash))
-            );
-            break;
+            return offers.maturity;
           case "expiry":
-            offers = offers.filter(
-              (o) => (sortOrder === "asc" ? o.expiry >= cursor.expiry : o.expiry <= cursor.expiry) && (o.expiry !== cursor.expiry || (sortOrder === "asc" ? o.hash > cursor.hash : o.hash < cursor.hash))
-            );
-            break;
+            return offers.expiry;
           case "amount":
-            offers = offers.filter(
-              (o) => (sortOrder === "asc" ? o.assets >= BigInt(cursor.assets) : o.assets <= BigInt(cursor.assets)) && (o.assets !== BigInt(cursor.assets) || (sortOrder === "asc" ? o.hash > cursor.hash : o.hash < cursor.hash))
-            );
-            break;
+            return offers.assets;
           default:
-            throw new Error("Invalid sort parameter");
+            return offers.expiry;
+        }
+      })();
+      const cursor = decode(query?.cursor);
+      if (cursor) {
+        if (cursor.sort !== sortBy || cursor.dir !== sortOrder) {
+          throw new Error("Cursor does not match the current sort parameters");
         }
-        offers = offers.filter((o) => o.hash !== cursor.hash);
+        const op = sortOrder === "asc" ? sql`>` : sql`<`;
+        const cursorVal = (() => {
+          switch (sortBy) {
+            case "rate":
+              return BigInt(cursor.rate);
+            case "amount":
+              return BigInt(cursor.assets);
+            case "maturity":
+              return cursor.maturity;
+            case "expiry":
+              return cursor.expiry;
+            default:
+              return cursor.expiry;
+          }
+        })();
+        conditions.push(sql`(${sortColumn}, ${offers.hash}) ${op} (${cursorVal}, ${cursor.hash})`);
       }
-      creators && (creators = creators.map((c) => c.toLowerCase()));
-      loanTokens && (loanTokens = loanTokens.map((lt) => lt.toLowerCase()));
-      callbackAddresses && (callbackAddresses = callbackAddresses.map((ca) => ca.toLowerCase()));
-      collateralAssets && (collateralAssets = collateralAssets.map((ca) => ca.toLowerCase()));
-      collateralOracles && (collateralOracles = collateralOracles.map((co) => co.toLowerCase()));
-      collateralTuple && (collateralTuple = collateralTuple.map((ct) => ({
-        asset: ct.asset.toLowerCase(),
-        oracle: ct.oracle?.toLowerCase()
-      })));
-      offers = offers.filter((o) => o.expiry >= now);
-      creators && (offers = offers.filter((o) => creators.includes(o.offering.toLowerCase())));
-      side && (offers = offers.filter((o) => o.buy === buy));
-      chains && (offers = offers.filter((o) => chains.includes(Number(o.chainId))));
-      loanTokens && (offers = offers.filter((o) => loanTokens.includes(o.loanToken.toLowerCase())));
-      status && (offers = offers.filter((o) => status.includes(o.status)));
-      callbackAddresses && (offers = offers.filter(
-        (o) => callbackAddresses.includes(o.callback.address.toLowerCase())
-      ));
-      minAmount && (offers = offers.filter((o) => o.assets >= minAmount));
-      maxAmount && (offers = offers.filter((o) => o.assets <= maxAmount));
-      minRate && (offers = offers.filter((o) => o.rate >= minRate));
-      maxRate && (offers = offers.filter((o) => o.rate <= maxRate));
-      minMaturity && (offers = offers.filter((o) => o.maturity >= minMaturity));
-      maxMaturity && (offers = offers.filter((o) => o.maturity <= maxMaturity));
-      minExpiry && (offers = offers.filter((o) => o.expiry >= minExpiry));
-      maxExpiry && (offers = offers.filter((o) => o.expiry <= maxExpiry));
-      collateralAssets && (offers = offers.filter(
-        (o) => o.collaterals.some((c) => collateralAssets.includes(c.asset.toLowerCase()))
-      ));
-      collateralOracles && (offers = offers.filter(
-        (o) => o.collaterals.some((c) => collateralOracles.includes(c.oracle.toLowerCase()))
-      ));
-      collateralTuple && (offers = offers.filter(
-        (o) => o.collaterals.some(
-          (c) => collateralTuple.some(
-            (ct) => c.asset.toLowerCase() === ct.asset.toLowerCase() && (ct.oracle ? c.oracle.toLowerCase() === ct.oracle.toLowerCase() : true) && (ct.lltv ? c.lltv === LLTV.from(BigInt(ct.lltv)) : true)
-          )
+      const limit = query?.limit ?? 20;
+      const latestStatus = db.select({
+        status: offerStatus.status,
+        metadata: offerStatus.metadata
+      }).from(offerStatus).where(eq(offerStatus.offerHash, offers.hash)).orderBy(desc(offerStatus.createdAt)).limit(1).as("latest_status");
+      const sumConsumed = db.select({
+        consumed: sql`COALESCE(SUM(${consumed.consumed}), 0)`.as("consumed")
+      }).from(consumed).where(
+        and(
+          eq(consumed.offering, offers.offering),
+          eq(consumed.nonce, offers.nonce),
+          eq(consumed.chainId, offers.chainId)
+        )
+      ).as("sum_consumed");
+      const results = await db.select({
+        hash: offers.hash,
+        offering: offers.offering,
+        assets: offers.assets,
+        consumed: sumConsumed.consumed,
+        rate: offers.rate,
+        maturity: offers.maturity,
+        expiry: offers.expiry,
+        start: offers.start,
+        nonce: offers.nonce,
+        buy: offers.buy,
+        chainId: offers.chainId,
+        loanToken: offers.loanToken,
+        callbackAddress: offers.callbackAddress,
+        callbackData: offers.callbackData,
+        callbackGasLimit: offers.callbackGasLimit,
+        signature: offers.signature,
+        createdAt: offers.createdAt,
+        collateralAsset: offerCollaterals.asset,
+        collateralOracle: offerCollaterals.oracle,
+        collateralLltv: offerCollaterals.lltv,
+        status: latestStatus.status,
+        metadata: latestStatus.metadata
+      }).from(offers).leftJoin(offerCollaterals, eq(offers.hash, offerCollaterals.offerHash)).leftJoinLateral(latestStatus, sql`true`).leftJoinLateral(sumConsumed, sql`true`).where(
+        and(
+          conditions.length > 0 ? and(...conditions) : sql`true`,
+          query?.status && query.status.length > 0 ? inArray(latestStatus.status, query.status) : eq(latestStatus.status, "valid"),
+          sql`( ${offers.assets} - COALESCE(${sumConsumed.consumed}, 0) ) > 0`
         )
-      ));
-      minLltv && (offers = offers.filter(
-        (o) => o.collaterals.every((c) => c.lltv >= parseUnits(minLltv.toString(), 16))
-      ));
-      maxLltv && (offers = offers.filter(
-        (o) => o.collaterals.every((c) => c.lltv <= parseUnits(maxLltv.toString(), 16))
-      ));
-      offers = offers.sort((a, b) => sort(sortBy, sortOrder, a, b));
+      ).orderBy(
+        ...sortOrder === "asc" ? [asc(sortColumn), asc(offers.hash)] : [desc(sortColumn), desc(offers.hash)]
+      ).limit(limit);
+      const offerMap = /* @__PURE__ */ new Map();
+      for (const row of results) {
+        const offer = offerMap.get(row.hash) || {
+          hash: row.hash,
+          offering: row.offering,
+          assets: BigInt(row.assets),
+          consumed: BigInt(row.consumed),
+          rate: row.rate,
+          maturity: row.maturity,
+          expiry: row.expiry,
+          start: row.start,
+          nonce: row.nonce,
+          buy: row.buy,
+          chainId: row.chainId,
+          loanToken: row.loanToken,
+          callbackAddress: row.callbackAddress,
+          callbackData: row.callbackData,
+          callbackGasLimit: row.callbackGasLimit,
+          signature: row.signature,
+          createdAt: row.createdAt,
+          collaterals: [],
+          status: row.status,
+          metadata: row.metadata
+        };
+        if (row.collateralAsset && row.collateralOracle && row.collateralLltv) {
+          offer.collaterals.push({
+            asset: row.collateralAsset,
+            oracle: row.collateralOracle,
+            lltv: LLTV.from(row.collateralLltv)
+          });
+        }
+        offerMap.set(row.hash, offer);
+      }
       let nextCursor = null;
-      if (offers.length > limit) {
-        const last = offers[limit - 1];
+      if (results.length === limit && results.length > 0) {
+        const lastRow = results[results.length - 1];
         const base = {
           sort: sortBy,
           dir: sortOrder,
-          hash: last.hash
+          hash: lastRow.hash
         };
         switch (sortBy) {
           case "rate":
-            base.rate = last.rate.toString();
+            base.rate = lastRow.rate.toString();
             break;
           case "amount":
-            base.assets = last.assets.toString();
+            base.assets = lastRow.assets.toString();
             break;
           case "maturity":
-            base.maturity = last.maturity;
+            base.maturity = lastRow.maturity;
             break;
           default:
-            base.expiry = last.expiry;
+            base.expiry = lastRow.expiry;
         }
         nextCursor = encode(base);
       }
-      offers = offers.slice(0, limit);
-      const data = offers.map((o) => ({
-        ...Offer.from({
-          offering: o.offering,
-          assets: o.assets,
-          rate: o.rate,
-          maturity: Maturity.from(o.maturity),
-          expiry: o.expiry,
-          start: o.start,
-          nonce: o.nonce,
-          buy: o.buy,
-          chainId: o.chainId,
-          loanToken: o.loanToken,
-          collaterals: o.collaterals.map((c) => ({ asset: c.asset, oracle: c.oracle, lltv: c.lltv })).sort((a, b) => a.asset.toLowerCase().localeCompare(b.asset.toLowerCase())),
+      const transformedResults = [];
+      for (const offerData of offerMap.values()) {
+        const offer = Offer.from({
+          offering: offerData.offering,
+          assets: offerData.assets,
+          rate: offerData.rate,
+          maturity: Maturity.from(offerData.maturity),
+          expiry: offerData.expiry,
+          start: offerData.start,
+          nonce: offerData.nonce,
+          buy: offerData.buy,
+          chainId: offerData.chainId,
+          loanToken: offerData.loanToken,
+          collaterals: offerData.collaterals.map((c) => ({
+            asset: c.asset,
+            oracle: c.oracle,
+            lltv: LLTV.from(c.lltv)
+          })).sort((a, b) => a.asset.toLowerCase().localeCompare(b.asset.toLowerCase())),
           callback: {
-            address: o.callback.address,
-            data: o.callback.data,
-            gasLimit: o.callback.gasLimit
+            address: offerData.callbackAddress,
+            data: offerData.callbackData,
+            gasLimit: offerData.callbackGasLimit
           },
-          ...o.signature !== null && o.signature !== void 0 ? { signature: o.signature } : {}
-        }),
-        consumed: o.consumed,
-        status: o.status,
-        ...o.metadata ? { metadata: o.metadata } : {}
-      }));
-      return {
-        offers: data,
-        nextCursor
-      };
+          ...offerData.signature !== null ? { signature: offerData.signature } : void 0
+        });
+        transformedResults.push({
+          ...offer,
+          consumed: offerData.consumed,
+          status: offerData.status,
+          ...offerData.metadata !== null ? { metadata: offerData.metadata } : void 0
+        });
+      }
+      return { offers: transformedResults, nextCursor };
     },
+    /**
+     * Returns offers that match specified offer based on the provided parameters.
+     *
+     * Rules for filtering:
+     * - If offer expiry is in the past compared to now, it should not be included
+     * - If offer maturity is in the past compared to now, it should not be included
+     * - It should return if buyOffer.rate >= sellOffer.rate
+     * - It should return if buyOffer.userAddress != sellOffer.userAddress
+     * - It should return if maturity matches
+     * - It should return if loanToken matches
+     * - If the incoming intent is a buy / lend offer, only consider existing sell / borrow offers.
+     * - If the incoming intent is a sell / borrow offer, only consider existing buy / lend offers.
+     * - When the intent is lend: require offer_collaterals ⊆ intent_collaterals
+     * - When the intent is borrow: require intent_collaterals ⊆ offer_collaterals
+     * - It should sort by increasing rate if the input offer is a buy/lend offer
+     * - It should sort by decreasing rate if the input offer is a sell/borrow offer
+     */
     findMatchingOffers: async (params) => {
       const {
         side,
@@ -1258,645 +2288,872 @@ function memory(parameters) {
         maxMaturity,
         loanToken,
         creator,
-        cursor: queryCursor,
+        cursor,
         limit = 20
       } = params;
-      const now = Time.now();
-      const isBuying = side === "buy";
-      const sortOrder = isBuying ? "desc" : "asc";
-      let offers = Array.from(map.values()).map((o) => ({
-        ...o,
-        consumed: filled.get(o.chainId)?.get(o.offering.toLowerCase())?.get(o.nonce) || 0n
-      })).filter((o) => o.consumed < o.assets);
-      const cursor = decode(queryCursor);
-      if (cursor) {
-        if (cursor.sort !== "rate" || cursor.dir !== sortOrder) {
+      const isIncomingBuy = side === "buy";
+      const nowEpochSeconds = Math.floor(Date.now() / 1e3);
+      const rateSortDirection = isIncomingBuy ? "desc" : "asc";
+      const baseWhereClauses = [];
+      baseWhereClauses.push(eq(offers.buy, !isIncomingBuy));
+      baseWhereClauses.push(eq(offers.chainId, BigInt(chainId)));
+      baseWhereClauses.push(gte(offers.expiry, nowEpochSeconds));
+      baseWhereClauses.push(gte(offers.maturity, nowEpochSeconds));
+      if (maturity) baseWhereClauses.push(eq(offers.maturity, maturity));
+      if (minMaturity) baseWhereClauses.push(gte(offers.maturity, minMaturity));
+      if (maxMaturity) baseWhereClauses.push(lte(offers.maturity, maxMaturity));
+      if (loanToken) baseWhereClauses.push(eq(offers.loanToken, loanToken.toLowerCase()));
+      if (creator) baseWhereClauses.push(eq(offers.offering, creator.toLowerCase()));
+      if (rate)
+        baseWhereClauses.push(isIncomingBuy ? gte(offers.rate, rate) : lte(offers.rate, rate));
+      const parsedCursor = decode(cursor);
+      if (parsedCursor) {
+        if (parsedCursor.sort !== "rate" || parsedCursor.dir !== rateSortDirection) {
           throw new Error("Cursor does not match the current sort parameters");
         }
-        offers = offers.filter(
-          (o) => sortOrder === "asc" ? o.rate >= BigInt(cursor.rate) : o.rate <= BigInt(cursor.rate)
-        );
       }
-      offers = offers.filter((o) => o.buy === !isBuying);
-      offers = offers.filter((o) => o.chainId === BigInt(chainId));
-      offers = offers.filter((o) => o.expiry >= now);
-      rate && (offers = offers.filter((o) => isBuying ? o.rate >= rate : o.rate <= rate));
-      collaterals.length > 0 && (offers = offers.filter(
-        (o) => isBuying ? (
-          // when wanting to buy, sell offer collaterals ⊆ user buy collaterals
-          o.collaterals.every((oc) => {
-            return collaterals.some(
-              (c) => oc.asset.toLowerCase() === c.asset.toLowerCase() && oc.oracle.toLowerCase() === c.oracle.toLowerCase() && oc.lltv === c.lltv
-            );
-          })
-        ) : (
-          // when wanting to sell, user sell collaterals ⊆ buy offer collaterals
-          collaterals.every((c) => {
-            return o.collaterals.some(
-              (oc) => oc.asset.toLowerCase() === c.asset.toLowerCase() && oc.oracle.toLowerCase() === c.oracle.toLowerCase() && oc.lltv === c.lltv
-            );
-          })
+      if (collaterals.length > 0) {
+        const collateralValues = collaterals.map(
+          (c) => `('${c.asset.toLowerCase()}', '${c.oracle.toLowerCase()}', ${c.lltv.toString()})`
+        ).join(", ");
+        const userCollaterals = sql`(VALUES ${sql.raw(collateralValues)}) AS user_collaterals(asset, oracle, lltv)`;
+        const sellPredicate = sql`
+          NOT EXISTS (
+            SELECT 1 FROM ${userCollaterals}
+            WHERE NOT EXISTS (
+              SELECT 1 FROM ${offerCollaterals} offer_collaterals
+              WHERE offer_collaterals.offer_hash = ${offers.hash}
+                AND offer_collaterals.asset   = user_collaterals.asset
+                AND offer_collaterals.oracle  = user_collaterals.oracle
+                AND offer_collaterals.lltv    = user_collaterals.lltv
+            )
+          )
+        `;
+        const buyPredicate = sql`
+          NOT EXISTS (
+            SELECT 1 FROM ${offerCollaterals} offer_collaterals
+            WHERE offer_collaterals.offer_hash = ${offers.hash}
+              AND NOT EXISTS (
+                SELECT 1 FROM ${userCollaterals}
+                WHERE user_collaterals.asset  = offer_collaterals.asset
+                  AND user_collaterals.oracle = offer_collaterals.oracle
+                  AND user_collaterals.lltv   = offer_collaterals.lltv
+              )
+          )
+        `;
+        baseWhereClauses.push(isIncomingBuy ? buyPredicate : sellPredicate);
+      }
+      const latestStatus = db.select({
+        status: offerStatus.status,
+        metadata: offerStatus.metadata
+      }).from(offerStatus).where(eq(offerStatus.offerHash, offers.hash)).orderBy(desc(offerStatus.createdAt)).limit(1).as("latest_status");
+      const sumConsumed = db.select({
+        consumed: sql`COALESCE(SUM(${consumed.consumed}), 0)`.as("consumed")
+      }).from(consumed).where(
+        and(
+          eq(consumed.offering, offers.offering),
+          eq(consumed.nonce, offers.nonce),
+          eq(consumed.chainId, offers.chainId)
         )
-      ));
-      maturity && (offers = offers.filter((o) => o.maturity === maturity));
-      minMaturity && (offers = offers.filter((o) => o.maturity >= minMaturity));
-      maxMaturity && (offers = offers.filter((o) => o.maturity <= maxMaturity));
-      loanToken && (offers = offers.filter((o) => o.loanToken.toLowerCase() === loanToken.toLowerCase()));
-      creator && (offers = offers.filter((o) => o.offering.toLowerCase() === creator.toLowerCase()));
-      offers = offers.filter((o) => ["valid"].includes(o.status));
-      const byGroup = /* @__PURE__ */ new Map();
-      for (const offer of offers) {
-        const groupKey = `${offer.chainId}-${offer.offering.toLowerCase()}-${offer.nonce}-${offer.buy}`;
-        const current = byGroup.get(groupKey);
-        if (!current) {
-          byGroup.set(groupKey, offer);
-          continue;
+      ).as("sum_consumed");
+      const statusCondition = eq(latestStatus.status, "valid");
+      const bestOffers = db.selectDistinctOn(
+        // group key
+        [offers.offering, offers.nonce, offers.buy],
+        {
+          hash: offers.hash,
+          offering: offers.offering,
+          assets: offers.assets,
+          consumed: sumConsumed.consumed,
+          remaining: sql`${offers.assets} - COALESCE(${sumConsumed.consumed}, 0)`.as("remaining"),
+          rate: offers.rate,
+          maturity: offers.maturity,
+          expiry: offers.expiry,
+          start: offers.start,
+          nonce: offers.nonce,
+          buy: offers.buy,
+          chainId: offers.chainId,
+          loanToken: offers.loanToken,
+          callbackAddress: offers.callbackAddress,
+          callbackData: offers.callbackData,
+          callbackGasLimit: offers.callbackGasLimit,
+          signature: offers.signature,
+          callbackId: offers.callbackId,
+          status: latestStatus.status,
+          metadata: latestStatus.metadata
         }
-        const remainingCandidate = offer.assets - offer.consumed;
-        const remainingCurrent = current.assets - current.consumed;
-        let candidateIsBetter = false;
-        if (offer.buy) {
-          if (offer.rate !== current.rate) candidateIsBetter = offer.rate < current.rate;
-          else if (remainingCandidate !== remainingCurrent)
-            candidateIsBetter = remainingCandidate > remainingCurrent;
-          else if (offer.maturity !== current.maturity)
-            candidateIsBetter = offer.maturity > current.maturity;
-          else candidateIsBetter = offer.hash < current.hash;
-        } else {
-          if (offer.rate !== current.rate) candidateIsBetter = offer.rate > current.rate;
-          else if (remainingCandidate !== remainingCurrent)
-            candidateIsBetter = remainingCandidate > remainingCurrent;
-          else if (offer.maturity !== current.maturity)
-            candidateIsBetter = offer.maturity > current.maturity;
-          else candidateIsBetter = offer.hash < current.hash;
+      ).from(offers).leftJoinLateral(latestStatus, sql`true`).leftJoinLateral(sumConsumed, sql`true`).where(
+        and(
+          and(...baseWhereClauses),
+          statusCondition,
+          sql`( ${offers.assets} - COALESCE(${sumConsumed.consumed}, 0) ) > 0`
+        )
+      ).orderBy(
+        offers.offering,
+        offers.nonce,
+        offers.buy,
+        // 1 price (direction depends on side)
+        sql`CASE WHEN ${offers.buy} THEN ${offers.rate} ELSE -${offers.rate} END`,
+        // 2 size (remaining)
+        sql`( ${offers.assets} - COALESCE(${sumConsumed.consumed}, 0) ) DESC`,
+        // 3 term (longer maturity)
+        desc(offers.maturity)
+      ).as("best_offers");
+      const queueLiquidity = db.select({
+        callbackId: userPositions.id,
+        userAmount: userPositions.amount,
+        // user's per-callback cap
+        queueLiquidity: sql`COALESCE(SUM(${availableLiquidityPools.amount}), 0)`.as(
+          "queue_liquidity"
+        )
+      }).from(userPositions).leftJoin(
+        availableLiquidityQueues,
+        eq(userPositions.availableLiquidityQueueId, availableLiquidityQueues.queueId)
+      ).leftJoin(
+        availableLiquidityPools,
+        eq(availableLiquidityQueues.availableLiquidityPoolId, availableLiquidityPools.id)
+      ).groupBy(userPositions.id).as("queue_liquidity");
+      const sortExpr = sql`CASE WHEN ${bestOffers.buy} THEN ${bestOffers.rate} ELSE -${bestOffers.rate} END`;
+      const offersWithEligibility = db.select({
+        hash: bestOffers.hash,
+        offering: bestOffers.offering,
+        assets: bestOffers.assets,
+        consumed: bestOffers.consumed,
+        remaining: bestOffers.remaining,
+        rate: bestOffers.rate,
+        maturity: bestOffers.maturity,
+        expiry: bestOffers.expiry,
+        start: bestOffers.start,
+        nonce: bestOffers.nonce,
+        buy: bestOffers.buy,
+        chainId: bestOffers.chainId,
+        loanToken: bestOffers.loanToken,
+        callbackAddress: bestOffers.callbackAddress,
+        callbackData: bestOffers.callbackData,
+        callbackGasLimit: bestOffers.callbackGasLimit,
+        signature: bestOffers.signature,
+        callbackId: bestOffers.callbackId,
+        status: bestOffers.status,
+        metadata: bestOffers.metadata,
+        // liquidity caps
+        userAmount: sql`COALESCE(${queueLiquidity.userAmount}, 0)`.as("user_amount"),
+        queueLiquidity: sql`COALESCE(${queueLiquidity.queueLiquidity}, 0)`.as(
+          "queue_liquidity"
+        ),
+        // running total of remaining per callback, ordered by the *same* priority as selection
+        cumulativeRemaining: sql`
+            SUM(${bestOffers.remaining}) OVER (
+              PARTITION BY ${bestOffers.callbackId}
+              ORDER BY ${sortExpr}, ${asc(bestOffers.hash)}
+              ROWS UNBOUNDED PRECEDING
+            )
+          `.as("cumulative_remaining"),
+        eligible: sql`
+            CASE
+              WHEN ${bestOffers.buy} = false THEN true
+              WHEN ${bestOffers.remaining} <= 0 THEN false
+              ELSE ( SUM(${bestOffers.remaining}) OVER (
+                      PARTITION BY ${bestOffers.callbackId}
+                      ORDER BY ${sortExpr}, ${asc(bestOffers.hash)}
+                      ROWS UNBOUNDED PRECEDING
+                    )
+                    <= LEAST(
+                          COALESCE(${queueLiquidity.userAmount}, 0),
+                          COALESCE(${queueLiquidity.queueLiquidity}, 0)
+                        )
+              )
+            END
+          `.as("eligible")
+      }).from(bestOffers).leftJoin(queueLiquidity, eq(bestOffers.callbackId, queueLiquidity.callbackId)).as("offers_with_eligibility");
+      const hardCap = limit * 5 + 1 + (parsedCursor ? 1 : 0);
+      const validOffers = db.select({
+        // pass-through all fields + a global row_number for hard cap
+        hash: offersWithEligibility.hash,
+        offering: offersWithEligibility.offering,
+        assets: offersWithEligibility.assets,
+        consumed: offersWithEligibility.consumed,
+        remaining: offersWithEligibility.remaining,
+        rate: offersWithEligibility.rate,
+        maturity: offersWithEligibility.maturity,
+        expiry: offersWithEligibility.expiry,
+        start: offersWithEligibility.start,
+        nonce: offersWithEligibility.nonce,
+        buy: offersWithEligibility.buy,
+        chainId: offersWithEligibility.chainId,
+        loanToken: offersWithEligibility.loanToken,
+        callbackAddress: offersWithEligibility.callbackAddress,
+        callbackData: offersWithEligibility.callbackData,
+        callbackGasLimit: offersWithEligibility.callbackGasLimit,
+        signature: offersWithEligibility.signature,
+        callbackId: offersWithEligibility.callbackId,
+        status: offersWithEligibility.status,
+        metadata: offersWithEligibility.metadata,
+        userAmount: offersWithEligibility.userAmount,
+        queueLiquidity: offersWithEligibility.queueLiquidity,
+        cumulativeRemaining: offersWithEligibility.cumulativeRemaining,
+        eligible: offersWithEligibility.eligible,
+        // sort expression is the same again as in offersWithEligibility
+        rowNumber: sql`
+      ROW_NUMBER() OVER (
+        ORDER BY
+        CASE WHEN ${offersWithEligibility.buy} THEN ${offersWithEligibility.rate} ELSE -${offersWithEligibility.rate} END,
+        ${asc(offersWithEligibility.hash)}
+      )
+    `.as("row_number")
+      }).from(offersWithEligibility).where(sql`${offersWithEligibility.eligible} = true`).limit(hardCap).as("valid_offers");
+      const cursorTuple = parsedCursor ? {
+        rate: BigInt(parsedCursor.rate),
+        hash: parsedCursor.hash
+      } : null;
+      const withCollats = await db.select({
+        // base fields
+        hash: sql`${validOffers.hash}`,
+        offering: sql`${validOffers.offering}`,
+        assets: validOffers.assets,
+        consumed: validOffers.consumed,
+        rate: validOffers.rate,
+        maturity: validOffers.maturity,
+        expiry: validOffers.expiry,
+        start: validOffers.start,
+        nonce: validOffers.nonce,
+        buy: validOffers.buy,
+        chainId: validOffers.chainId,
+        loanToken: sql`${validOffers.loanToken}`,
+        callbackAddress: sql`${validOffers.callbackAddress}`,
+        callbackData: sql`${validOffers.callbackData}`,
+        callbackGasLimit: validOffers.callbackGasLimit,
+        signature: sql`${validOffers.signature}`,
+        callbackId: validOffers.callbackId,
+        status: sql`${validOffers.status}`,
+        metadata: validOffers.metadata,
+        // collateral fields
+        collateralAsset: sql`${offerCollaterals.asset}`,
+        collateralOracle: sql`${offerCollaterals.oracle}`,
+        collateralLltv: offerCollaterals.lltv
+      }).from(validOffers).leftJoin(offerCollaterals, eq(validOffers.hash, offerCollaterals.offerHash)).where(
+        and(
+          ...cursorTuple ? [
+            sql`(${validOffers.rate}, ${validOffers.hash}) ${rateSortDirection === "asc" ? sql`>` : sql`<`} (${cursorTuple.rate}, ${cursorTuple.hash})`
+          ] : []
+        )
+      ).orderBy(
+        rateSortDirection === "asc" ? asc(validOffers.rate) : desc(validOffers.rate),
+        asc(validOffers.hash)
+      );
+      const buildOffersMap = (rows, skipHash) => {
+        const map = /* @__PURE__ */ new Map();
+        for (const row of rows) {
+          const entry = map.get(row.hash) ?? { base: row, collaterals: [] };
+          if (row.collateralAsset && row.collateralOracle && row.collateralLltv) {
+            entry.collaterals.push({
+              asset: row.collateralAsset,
+              oracle: row.collateralOracle,
+              lltv: LLTV.from(row.collateralLltv)
+            });
+          }
+          map.set(row.hash, entry);
         }
-        if (candidateIsBetter) byGroup.set(groupKey, offer);
-      }
-      offers = Array.from(byGroup.values());
-      offers = offers.sort((a, b) => sort("rate", sortOrder, a, b));
-      cursor && (offers = offers.filter((o) => o.hash !== cursor.hash));
+        return map;
+      };
+      const allEntries = Array.from(buildOffersMap(withCollats).values());
+      const pageEntries = allEntries.slice(0, limit);
       let nextCursor = null;
-      if (offers.length > limit) {
-        const last = offers[limit - 1];
+      if (allEntries.length > limit) {
+        const last = pageEntries[pageEntries.length - 1].base;
         nextCursor = encode({
           sort: "rate",
-          dir: sortOrder,
+          dir: rateSortDirection,
           hash: last.hash,
           rate: last.rate.toString()
         });
       }
-      offers = offers.slice(0, limit);
-      const data = offers.map((o) => ({
+      const data = pageEntries.map(({ base, collaterals: cols }) => ({
         ...Offer.from({
-          offering: o.offering,
-          assets: o.assets,
-          rate: o.rate,
-          maturity: Maturity.from(o.maturity),
-          expiry: o.expiry,
-          start: o.start,
-          nonce: o.nonce,
-          buy: o.buy,
-          chainId: o.chainId,
-          loanToken: o.loanToken,
-          collaterals: o.collaterals.map((c) => ({ asset: c.asset, oracle: c.oracle, lltv: c.lltv })).sort((a, b) => a.asset.toLowerCase().localeCompare(b.asset.toLowerCase())),
+          offering: base.offering,
+          assets: BigInt(base.assets),
+          rate: base.rate,
+          maturity: Maturity.from(base.maturity),
+          expiry: base.expiry,
+          start: base.start,
+          nonce: base.nonce,
+          buy: base.buy,
+          chainId: base.chainId,
+          loanToken: base.loanToken,
+          collaterals: cols.sort(
+            (a, b) => a.asset.toLowerCase().localeCompare(b.asset.toLowerCase())
+          ),
           callback: {
-            address: o.callback.address,
-            data: o.callback.data,
-            gasLimit: o.callback.gasLimit
+            address: base.callbackAddress,
+            data: base.callbackData,
+            gasLimit: base.callbackGasLimit
           },
-          ...o.signature !== null && o.signature !== void 0 ? { signature: o.signature } : {}
+          ...base.signature !== null ? { signature: base.signature } : void 0
         }),
-        consumed: o.consumed,
-        status: o.status,
-        ...o.metadata ? { metadata: o.metadata } : {}
+        consumed: BigInt(base.consumed),
+        status: base.status,
+        ...base.metadata ? { metadata: base.metadata } : {}
       }));
-      return {
-        offers: data,
-        nextCursor
-      };
+      return { offers: data, nextCursor };
     },
     delete: async (hash) => {
-      if (!map.has(hash.toLowerCase())) return false;
-      map.delete(hash.toLowerCase());
-      return true;
+      const result = await db.delete(offers).where(eq(offers.hash, hash.toLowerCase()));
+      return result.affectedRows > 0;
     },
     deleteMany: async (hashes) => {
-      let deleted = 0;
-      for (const hash of hashes) {
-        if (map.has(hash.toLowerCase())) {
-          map.delete(hash.toLowerCase());
-          deleted++;
-        }
+      if (hashes.length === 0) {
+        return 0;
       }
-      return deleted;
+      return await db.transaction(async (tx) => {
+        const normalizedHashes = hashes.map((hash) => hash.toLowerCase());
+        const result = await tx.delete(offers).where(
+          sql`${offers.hash} = ANY(${sql.raw(`ARRAY[${normalizedHashes.map((h) => `'${h}'`).join(", ")}]`)})`
+        );
+        return result.affectedRows;
+      });
     },
-    updateStatus: async (parameters2) => {
-      const key = parameters2.offerHash.toLowerCase();
-      const existing = map.get(key);
-      if (!existing) return;
-      if (existing.status === parameters2.status) return;
-      map.set(key, {
-        ...existing,
-        status: parameters2.status,
-        metadata: parameters2.metadata
+    updateStatus: async (parameters) => {
+      const latest = await db.select({ status: offerStatus.status }).from(offerStatus).where(eq(offerStatus.offerHash, parameters.offerHash.toLowerCase())).orderBy(desc(offerStatus.createdAt)).limit(1);
+      if (latest.length > 0 && latest[0].status === parameters.status) return;
+      await db.insert(offerStatus).values({
+        offerHash: parameters.offerHash.toLowerCase(),
+        status: parameters.status,
+        metadata: parameters.metadata
       });
     },
-    updateConsumedAmount: async (parameters2) => {
-      if (consumedIds.has(parameters2.id)) return;
-      consumedIds.add(parameters2.id);
-      const chainId = parameters2.chainId;
-      const address = parameters2.offering.toLowerCase();
-      const nonce = parameters2.nonce;
-      const filledForChain = filled.get(chainId) || /* @__PURE__ */ new Map();
-      const filledForOffering = filledForChain.get(address) || /* @__PURE__ */ new Map();
-      const current = filledForOffering.get(nonce) || 0n;
-      filledForOffering.set(nonce, current + parameters2.consumed);
-      filledForChain.set(address, filledForOffering);
-      filled.set(chainId, filledForChain);
+    updateConsumedAmount: async (parameters) => {
+      await db.insert(consumed).values({
+        id: parameters.id,
+        chainId: parameters.chainId,
+        offering: parameters.offering.toLowerCase(),
+        nonce: parameters.nonce,
+        consumed: parameters.consumed.toString()
+      }).onConflictDoNothing();
     }
   };
 }
 
-// src/core/router/Server.ts
-async function serve(parameters) {
-  const app = new Hono();
-  const store = parameters.store ? parameters.store : memory({
-    offers: /* @__PURE__ */ new Map(),
-    filled: /* @__PURE__ */ new Map()
-  });
-  app.get("/v1/offers", async (c) => {
-    try {
-      const params = parse("get_offers", c.req.query());
-      const offers = await store.getAll({
-        query: {
-          creators: params.creators,
-          side: params.side,
-          chains: params.chains,
-          loanTokens: params.loan_tokens,
-          status: params.status,
-          callbackAddresses: params.callback_addresses,
-          minAmount: params.min_amount,
-          maxAmount: params.max_amount,
-          minRate: params.min_rate,
-          maxRate: params.max_rate,
-          minMaturity: params.min_maturity,
-          maxMaturity: params.max_maturity,
-          minExpiry: params.min_expiry,
-          maxExpiry: params.max_expiry,
-          collateralAssets: params.collateral_assets,
-          collateralOracles: params.collateral_oracles,
-          collateralTuple: params.collateral_tuple,
-          minLltv: params.min_lltv,
-          maxLltv: params.max_lltv,
-          sortBy: params.sort_by,
-          sortOrder: params.sort_order,
-          cursor: params.cursor,
-          limit: params.limit
-        }
-      });
-      return success(c, {
-        data: offers.offers.map(
-          (offer) => Format.stringifyBigint(Format.toSnakeCase(toResponse(offer)))
-        ),
-        cursor: offers.nextCursor ?? null
-      });
-    } catch (err) {
-      console.error(err);
-      return error(err, c);
-    }
-  });
-  app.get("/v1/offers/match", async (c) => {
-    try {
-      const params = parse("match_offers", c.req.query());
-      const offers = await store.findMatchingOffers({
-        side: params.side,
-        chainId: params.chain_id,
-        rate: params.rate,
-        collaterals: params.collaterals,
-        maturity: params.maturity,
-        minMaturity: params.min_maturity,
-        maxMaturity: params.max_maturity,
-        loanToken: params.loan_token,
-        creator: params.creator,
-        cursor: params.cursor,
-        limit: params.limit
-      });
-      return success(c, {
-        data: offers.offers.map(
-          (offer) => Format.stringifyBigint(Format.toSnakeCase(toResponse(offer)))
-        ),
-        cursor: offers.nextCursor ?? null
-      });
-    } catch (err) {
-      console.error(err);
-      return error(err, c);
-    }
-  });
-  serve$1(
-    {
-      fetch: app.fetch,
-      port: parameters.port
-    },
-    (info) => {
-      console.log(`Started local router @ http://localhost:${info.port}`);
-    }
-  );
+// src/core/OfferStore/PG.ts
+var PG_exports = {};
+__export(PG_exports, {
+  applyMigrations: () => applyMigrations,
+  clean: () => clean,
+  connect: () => connect
+});
+function connect(parameters) {
+  if (parameters.type === "pg") {
+    const pool2 = new Pool({ connectionString: parameters.endpoint });
+    const client2 = drizzle(pool2, { schema: schema_exports });
+    return Object.assign(client2, { name: "pg", pool: pool2 });
+  }
+  const pool = new PGlite();
+  const client = drizzle$1(pool, { schema: schema_exports });
+  return Object.assign(client, { name: "pglite", pool });
 }
-function error(error2, c) {
-  if (error2 instanceof APIError) {
-    return handleAPIError(error2, c);
+async function applyMigrations(pg) {
+  const migrationsFolder = process.env.AWS_LAMBDA_FUNCTION_NAME ? path.join(process.cwd(), "drizzle", VERSION) : path.join(__dirname, "drizzle", VERSION);
+  await pg.execute(`create schema if not exists "${VERSION}"`);
+  if (pg.name === "pg") {
+    await migrate(pg, { migrationsFolder });
+    return;
+  }
+  await migrate$1(pg, { migrationsFolder });
+}
+async function clean(pg) {
+  await pg.execute(`drop schema if exists "${VERSION}" cascade`);
+  await pg.execute(`create schema "${VERSION}"`);
+  await pg.execute("drop schema if exists drizzle cascade");
+}
+
+// src/core/router/index.ts
+var router_exports = {};
+__export(router_exports, {
+  APIError: () => APIError,
+  BadRequestError: () => BadRequestError,
+  HttpForbiddenError: () => HttpForbiddenError,
+  HttpGetOffersFailedError: () => HttpGetOffersFailedError,
+  HttpRateLimitError: () => HttpRateLimitError,
+  HttpUnauthorizedError: () => HttpUnauthorizedError,
+  InternalServerError: () => InternalServerError,
+  InvalidUrlError: () => InvalidUrlError,
+  NotFoundError: () => NotFoundError,
+  ValidationError: () => ValidationError,
+  connect: () => connect2,
+  error: () => error,
+  get: () => get,
+  handleZodError: () => handleZodError,
+  match: () => match,
+  serve: () => serve,
+  success: () => success
+});
+function connect2(opts) {
+  const u = new URL(opts?.url || "https://router.morpho.dev");
+  if (u.protocol !== "http:" && u.protocol !== "https:") {
+    throw new InvalidUrlError(u.toString());
   }
-  if (error2 instanceof SyntaxError) {
-    return handleAPIError(new BadRequestError(error2.message), c);
+  const headers = opts?.headers ?? new Headers();
+  headers.set("Content-Type", "application/json");
+  opts?.apiKey !== void 0 ? headers.set("X-API-Key", opts.apiKey) : null;
+  const config = {
+    url: u,
+    headers
+  };
+  return {
+    ...config,
+    get: (parameters) => get(config, parameters),
+    match: (parameters) => match(config, parameters)
+  };
+}
+async function get(config, parameters) {
+  const url = new URL(`${config.url.toString()}v1/offers`);
+  if (parameters.creators?.length) {
+    url.searchParams.set("creators", parameters.creators.join(","));
   }
-  if (error2 instanceof z.ZodError) {
-    return handleAPIError(handleZodError(error2), c);
+  if (parameters.side) {
+    url.searchParams.set("side", parameters.side);
   }
-  return handleAPIError(new InternalServerError(), c);
-}
-function success(c, {
-  data,
-  cursor
-}) {
-  return c.json({
-    status: "success",
-    cursor,
-    data,
-    meta: {
-      timestamp: (/* @__PURE__ */ new Date()).toISOString()
-    }
-  });
-}
-var APIError = class extends Error {
-  constructor(statusCode, message, code, details) {
-    super(message);
-    this.statusCode = statusCode;
-    this.code = code;
-    this.details = details;
-    this.name = "APIError";
+  if (parameters.chains?.length) {
+    url.searchParams.set("chains", parameters.chains.join(","));
   }
-};
-var ValidationError = class extends APIError {
-  constructor(message, details) {
-    super(400, message, "VALIDATION_ERROR", details);
+  if (parameters.loanTokens?.length) {
+    url.searchParams.set("loan_tokens", parameters.loanTokens.join(","));
   }
-};
-var NotFoundError = class extends APIError {
-  constructor(message) {
-    super(404, message, "NOT_FOUND");
+  if (parameters.status?.length) {
+    url.searchParams.set("status", parameters.status.join(","));
   }
-};
-var InternalServerError = class extends APIError {
-  constructor(message = "Internal server error") {
-    super(500, message, "INTERNAL_SERVER_ERROR");
+  if (parameters.callbackAddresses?.length) {
+    url.searchParams.set("callback_addresses", parameters.callbackAddresses.join(","));
   }
-};
-var BadRequestError = class extends APIError {
-  constructor(message = "Invalid JSON format", details) {
-    super(400, message, "BAD_REQUEST", details);
+  if (parameters.minAmount !== void 0) {
+    url.searchParams.set("min_amount", parameters.minAmount.toString());
   }
-};
-function handleZodError(error2) {
-  const formattedErrors = error2.issues.map((err) => {
-    const field = err.path.join(".");
-    let issue = err.message;
-    if (err.code === "invalid_type") {
-      if (err.message.includes("received undefined")) {
-        issue = `${field} is required`;
-      } else {
-        issue = err.message;
+  if (parameters.maxAmount !== void 0) {
+    url.searchParams.set("max_amount", parameters.maxAmount.toString());
+  }
+  if (parameters.minRate !== void 0) {
+    url.searchParams.set("min_rate", parameters.minRate.toString());
+  }
+  if (parameters.maxRate !== void 0) {
+    url.searchParams.set("max_rate", parameters.maxRate.toString());
+  }
+  if (parameters.minMaturity !== void 0) {
+    url.searchParams.set("min_maturity", parameters.minMaturity.toString());
+  }
+  if (parameters.maxMaturity !== void 0) {
+    url.searchParams.set("max_maturity", parameters.maxMaturity.toString());
+  }
+  if (parameters.minExpiry !== void 0) {
+    url.searchParams.set("min_expiry", parameters.minExpiry.toString());
+  }
+  if (parameters.maxExpiry !== void 0) {
+    url.searchParams.set("max_expiry", parameters.maxExpiry.toString());
+  }
+  if (parameters.collateralAssets?.length) {
+    url.searchParams.set("collateral_assets", parameters.collateralAssets.join(","));
+  }
+  if (parameters.collateralOracles?.length) {
+    url.searchParams.set("collateral_oracles", parameters.collateralOracles.join(","));
+  }
+  if (parameters.collateralTuple?.length) {
+    const tupleStr = parameters.collateralTuple.map(({ asset, oracle, lltv }) => {
+      let result = asset;
+      if (oracle) {
+        result += `:${oracle}`;
+      } else if (lltv !== void 0) {
+        result += `:`;
       }
-    } else if (err.code === "invalid_format") {
-      issue = `${field} has an invalid format`;
-    }
-    return {
-      field,
-      issue
-    };
-  });
-  return new ValidationError("Validation failed", formattedErrors);
+      if (lltv !== void 0) result += `:${formatUnits(lltv, 16)}`;
+      return result;
+    }).join("#");
+    url.searchParams.set("collateral_tuple", tupleStr);
+  }
+  if (parameters.minLltv !== void 0) {
+    url.searchParams.set("min_lltv", formatUnits(parameters.minLltv, 16));
+  }
+  if (parameters.maxLltv !== void 0) {
+    url.searchParams.set("max_lltv", formatUnits(parameters.maxLltv, 16));
+  }
+  if (parameters.sortBy) {
+    url.searchParams.set("sort_by", parameters.sortBy);
+  }
+  if (parameters.sortOrder) {
+    url.searchParams.set("sort_order", parameters.sortOrder);
+  }
+  if (parameters.cursor) {
+    url.searchParams.set("cursor", parameters.cursor);
+  }
+  if (parameters.limit !== void 0) {
+    url.searchParams.set("limit", parameters.limit.toString());
+  }
+  const { cursor: returnedCursor, data: offers2 } = await getApi(config, url);
+  const routerOffers = offers2.map(Format.fromSnakeCase).map(fromResponse);
+  return {
+    cursor: returnedCursor,
+    offers: routerOffers.map(from).map(toResponse)
+  };
 }
-function handleAPIError(error2, c) {
-  return c.json({
-    statusCode: error2.statusCode,
-    body: JSON.stringify({
-      status: "error",
-      error: {
-        code: error2.code,
-        message: error2.message,
-        ...error2.details && typeof error2.details === "object" ? { details: error2.details } : {}
-      },
-      meta: {
-        timestamp: (/* @__PURE__ */ new Date()).toISOString()
-      }
-    })
-  });
+async function match(config, parameters) {
+  const url = new URL(`${config.url.toString()}v1/offers/match`);
+  url.searchParams.set("side", parameters.side);
+  url.searchParams.set("chain_id", parameters.chainId.toString());
+  if (parameters.rate !== void 0) {
+    url.searchParams.set("rate", parameters.rate.toString());
+  }
+  if (parameters.collaterals?.length) {
+    const collateralsStr = parameters.collaterals.map(({ asset, oracle, lltv }) => `${asset}:${oracle}:${formatUnits(lltv, 16)}`).join("#");
+    url.searchParams.set("collaterals", collateralsStr);
+  }
+  if (parameters.maturity !== void 0) {
+    url.searchParams.set("maturity", parameters.maturity.toString());
+  }
+  if (parameters.minMaturity !== void 0) {
+    url.searchParams.set("min_maturity", parameters.minMaturity.toString());
+  }
+  if (parameters.maxMaturity !== void 0) {
+    url.searchParams.set("max_maturity", parameters.maxMaturity.toString());
+  }
+  if (parameters.loanToken) {
+    url.searchParams.set("loan_token", parameters.loanToken);
+  }
+  if (parameters.creator) {
+    url.searchParams.set("creator", parameters.creator);
+  }
+  if (parameters.status?.length) {
+    url.searchParams.set("status", parameters.status.join(","));
+  }
+  if (parameters.cursor) {
+    url.searchParams.set("cursor", parameters.cursor);
+  }
+  if (parameters.limit !== void 0) {
+    url.searchParams.set("limit", parameters.limit.toString());
+  }
+  const { cursor: returnedCursor, data: offers2 } = await getApi(config, url);
+  const routerOffers = offers2.map(Format.fromSnakeCase).map(fromResponse);
+  return {
+    cursor: returnedCursor,
+    offers: routerOffers.map(from).map(toResponse)
+  };
 }
-
-// src/Liquidity.ts
-var Liquidity_exports = {};
-__export(Liquidity_exports, {
-  fetch: () => fetch2,
-  fetchBalancesAndAllowances: () => fetchBalancesAndAllowances,
-  serialize: () => serialize
-});
-async function fetchBalancesAndAllowances(parameters) {
-  const { client, spender, pairs, options } = parameters;
-  if (pairs.length === 0) return /* @__PURE__ */ new Map();
-  const batchSize = Math.max(1, options?.batchSize ?? 5e3);
-  const retryAttempts = Math.max(1, options?.retryAttempts ?? 3);
-  const retryDelayMs = Math.max(0, options?.retryDelayMs ?? 50);
-  const blockNumber = options?.blockNumber ? BigInt(options.blockNumber) : void 0;
-  const out = /* @__PURE__ */ new Map();
-  for (const pairsBatch of Utils.batch(pairs, batchSize)) {
-    const balanceContracts = [];
-    const allowanceContracts = [];
-    for (const { user, token } of pairsBatch) {
-      balanceContracts.push({
-        address: token,
-        abi: erc20Abi,
-        functionName: "balanceOf",
-        args: [user]
-      });
-      allowanceContracts.push({
-        address: token,
-        abi: erc20Abi,
-        functionName: "allowance",
-        args: [user, spender]
+async function getApi(config, url) {
+  const pathname = url.pathname;
+  let action;
+  switch (true) {
+    case pathname.includes("/v1/offers/match"):
+      action = "match_offers";
+      break;
+    case pathname.includes("/v1/offers"):
+      action = "get_offers";
+      break;
+    default:
+      throw new HttpGetOffersFailedError("Unknown endpoint", {
+        details: `Unsupported path: ${pathname}`
       });
-    }
-    const [balances, allowances] = await Promise.all([
-      Utils.retry(
-        () => client.multicall({
-          allowFailure: false,
-          contracts: balanceContracts,
-          ...blockNumber ? { blockNumber } : {}
-        }),
-        retryAttempts,
-        retryDelayMs
-      ),
-      Utils.retry(
-        () => client.multicall({
-          allowFailure: false,
-          contracts: allowanceContracts,
-          ...blockNumber ? { blockNumber } : {}
-        }),
-        retryAttempts,
-        retryDelayMs
-      )
-    ]);
-    for (let i = 0; i < pairsBatch.length; i++) {
-      const { user, token } = pairsBatch[i];
-      const balance = balances[i];
-      const allowance = allowances[i];
-      let perUser = out.get(user);
-      if (!perUser) {
-        perUser = /* @__PURE__ */ new Map();
-        out.set(user, perUser);
-      }
-      perUser.set(token, { balance, allowance });
-    }
   }
-  return out;
-}
-async function fetch2(parameters) {
-  const { client, chainId, spender, type, pairs, options } = parameters;
-  if (type !== "buy_with_empty_callback" /* BuyWithEmptyCallback */)
-    throw new Error(`CallbackType not implemented: ${type}`);
-  const map = await fetchBalancesAndAllowances({
-    client,
-    spender,
-    pairs: pairs.map(({ user, contract }) => ({ user, token: contract })),
-    options
+  const schemaParseResult = safeParse(action, Object.fromEntries(url.searchParams));
+  if (!schemaParseResult.success) {
+    throw new HttpGetOffersFailedError(`Invalid URL parameters`, {
+      details: schemaParseResult.error.issues[0]?.message
+    });
+  }
+  const response = await fetch(url.toString(), {
+    method: "GET",
+    headers: config.headers
   });
-  const out = [];
-  for (const [user, perContract] of map) {
-    for (const [contract, { balance, allowance }] of perContract) {
-      const amount = balance < allowance ? balance : allowance;
-      out.push(
-        buildLiquidity({
-          type,
-          user,
-          contract,
-          chainId,
-          amount: amount.toString(),
-          index: 0
-        })
-      );
+  if (!response.ok) {
+    switch (response.status) {
+      case 401:
+        throw new HttpUnauthorizedError();
+      case 403:
+        throw new HttpForbiddenError();
+      case 429:
+        throw new HttpRateLimitError();
     }
+    throw new HttpGetOffersFailedError(`GET request returned ${response.status}`, {
+      details: await response.text()
+    });
   }
-  return out;
-}
-function serialize(liquidity) {
-  const normalized = {
-    userPosition: {
-      id: liquidity.userPosition.id,
-      availableLiquidityQueueId: liquidity.userPosition.availableLiquidityQueueId,
-      user: liquidity.userPosition.user,
-      chainId: String(liquidity.userPosition.chainId),
-      amount: String(liquidity.userPosition.amount)
-    },
-    queues: liquidity.queues.map((queueWithPool) => ({
-      queue: {
-        queueId: queueWithPool.queue.queueId,
-        availableLiquidityPoolId: queueWithPool.queue.availableLiquidityPoolId,
-        index: queueWithPool.queue.index
-      },
-      pool: {
-        id: queueWithPool.pool.id,
-        amount: String(queueWithPool.pool.amount)
-      }
-    })).sort(
-      (left, right) => {
-        const leftQueueId = left.queue.queueId || "";
-        const rightQueueId = right.queue.queueId || "";
-        if (leftQueueId < rightQueueId) return -1;
-        if (leftQueueId > rightQueueId) return 1;
-        const leftPoolId = left.pool.id;
-        const rightPoolId = right.pool.id;
-        if (leftPoolId < rightPoolId) return -1;
-        if (leftPoolId > rightPoolId) return 1;
-        const leftIndex = left.queue.index;
-        const rightIndex = right.queue.index;
-        if (leftIndex < rightIndex) return -1;
-        if (leftIndex > rightIndex) return 1;
-        return 0;
-      }
-    )
-  };
-  return JSON.stringify(normalized);
+  return response.json();
 }
-
-// src/Logger.ts
-var Logger_exports = {};
-__export(Logger_exports, {
-  LogLevelValues: () => LogLevelValues,
-  defaultLogger: () => defaultLogger,
-  getLogger: () => getLogger,
-  runWithLogger: () => runWithLogger,
-  silentLogger: () => silentLogger
-});
-var LogLevelValues = [
-  "silent",
-  "trace",
-  "debug",
-  "info",
-  "warn",
-  "error",
-  "fatal"
-];
-function defaultLogger(minLevel) {
-  const threshold = minLevel ?? "trace";
-  const levelIndexByName = LogLevelValues.reduce(
-    (acc, lvl, idx) => {
-      acc[lvl] = idx;
-      return acc;
-    },
-    {}
-  );
-  const isEnabled = (methodLevel) => levelIndexByName[methodLevel] >= levelIndexByName[threshold];
-  return {
-    // biome-ignore lint/suspicious/noConsole: console is used for logging
-    trace: isEnabled("trace") ? console.trace.bind(console) : () => {
-    },
-    // biome-ignore lint/suspicious/noConsole: console is used for logging
-    debug: isEnabled("debug") ? console.debug.bind(console) : () => {
-    },
-    // biome-ignore lint/suspicious/noConsole: console is used for logging
-    info: isEnabled("info") ? console.info.bind(console) : () => {
-    },
-    // biome-ignore lint/suspicious/noConsole: console is used for logging
-    warn: isEnabled("warn") ? console.warn.bind(console) : () => {
-    },
-    // biome-ignore lint/suspicious/noConsole: console is used for logging
-    error: isEnabled("error") ? console.error.bind(console) : () => {
-    },
-    fatal: isEnabled("fatal") ? (...args) => console.error("[fatal]", ...args) : () => {
+var InvalidUrlError = class extends Errors.BaseError {
+  name = "Router.InvalidUrlError";
+  constructor(url) {
+    super(`URL "${url}" is not http/https.`);
+  }
+};
+var HttpUnauthorizedError = class extends Errors.BaseError {
+  name = "Router.HttpUnauthorizedError";
+  constructor() {
+    super("Unauthorized.", {
+      metaMessages: ["Ensure that an API key is provided."]
+    });
+  }
+};
+var HttpForbiddenError = class extends Errors.BaseError {
+  name = "Router.HttpForbiddenError";
+  constructor() {
+    super("Forbidden.", {
+      metaMessages: ["Ensure that the API key is valid."]
+    });
+  }
+};
+var HttpRateLimitError = class extends Errors.BaseError {
+  name = "Router.HttpRateLimitError";
+  constructor() {
+    super("Rate limit exceeded.", {
+      metaMessages: [
+        "The number of allowed requests has been exceeded. You must wait for the rate limit to reset."
+      ]
+    });
+  }
+};
+var HttpGetOffersFailedError = class extends Errors.BaseError {
+  name = "Router.HttpGetOffersFailedError";
+  constructor(message, { details } = {}) {
+    super(message, {
+      metaMessages: [details]
+    });
+  }
+};
+async function serve(parameters) {
+  const app = new Hono();
+  const store = parameters.store;
+  const logger = getLogger();
+  app.get("/v1/offers", async (c) => {
+    try {
+      const params = parse("get_offers", c.req.query());
+      const offers2 = await store.getAll({
+        query: {
+          creators: params.creators,
+          side: params.side,
+          chains: params.chains,
+          loanTokens: params.loan_tokens,
+          status: params.status,
+          callbackAddresses: params.callback_addresses,
+          minAmount: params.min_amount,
+          maxAmount: params.max_amount,
+          minRate: params.min_rate,
+          maxRate: params.max_rate,
+          minMaturity: params.min_maturity,
+          maxMaturity: params.max_maturity,
+          minExpiry: params.min_expiry,
+          maxExpiry: params.max_expiry,
+          collateralAssets: params.collateral_assets,
+          collateralOracles: params.collateral_oracles,
+          collateralTuple: params.collateral_tuple,
+          minLltv: params.min_lltv,
+          maxLltv: params.max_lltv,
+          sortBy: params.sort_by,
+          sortOrder: params.sort_order,
+          cursor: params.cursor,
+          limit: params.limit
+        }
+      });
+      return success(c, {
+        data: offers2.offers.map(
+          (offer) => Format.stringifyBigint(Format.toSnakeCase(toResponse(offer)))
+        ),
+        cursor: offers2.nextCursor ?? null
+      });
+    } catch (err) {
+      console.error(err);
+      return error(err, c);
     }
-  };
-}
-function silentLogger() {
-  return {
-    trace: () => {
-    },
-    debug: () => {
-    },
-    info: () => {
-    },
-    warn: () => {
-    },
-    error: () => {
+  });
+  app.get("/v1/offers/match", async (c) => {
+    try {
+      const params = parse("match_offers", c.req.query());
+      const offers2 = await store.findMatchingOffers({
+        side: params.side,
+        chainId: params.chain_id,
+        rate: params.rate,
+        collaterals: params.collaterals,
+        maturity: params.maturity,
+        minMaturity: params.min_maturity,
+        maxMaturity: params.max_maturity,
+        loanToken: params.loan_token,
+        creator: params.creator,
+        cursor: params.cursor,
+        limit: params.limit
+      });
+      return success(c, {
+        data: offers2.offers.map(
+          (offer) => Format.stringifyBigint(Format.toSnakeCase(toResponse(offer)))
+        ),
+        cursor: offers2.nextCursor ?? null
+      });
+    } catch (err) {
+      console.error(err);
+      return error(err, c);
+    }
+  });
+  serve$1(
+    {
+      fetch: app.fetch,
+      port: parameters.port
     },
-    fatal: () => {
+    (info) => {
+      logger.info({ service: "api", msg: "Router server started", port: info.port });
     }
-  };
+  );
 }
-var loggerContext = new AsyncLocalStorage();
-function runWithLogger(logger, fn) {
-  return loggerContext.run(logger, fn);
+function error(error2, c) {
+  if (error2 instanceof APIError) {
+    return handleAPIError(error2, c);
+  }
+  if (error2 instanceof SyntaxError) {
+    return handleAPIError(new BadRequestError(error2.message), c);
+  }
+  if (error2 instanceof z.ZodError) {
+    return handleAPIError(handleZodError(error2), c);
+  }
+  return handleAPIError(new InternalServerError(), c);
 }
-function getLogger() {
-  return loggerContext.getStore() ?? defaultLogger();
+function success(c, {
+  data,
+  cursor
+}) {
+  return c.json({
+    status: "success",
+    cursor,
+    data,
+    meta: {
+      timestamp: (/* @__PURE__ */ new Date()).toISOString()
+    }
+  });
 }
-
-// src/Validation.ts
-var Validation_exports = {};
-__export(Validation_exports, {
-  run: () => run
-});
-async function run(parameters) {
-  const { items, rules, ctx = {}, chunkSize } = parameters;
-  const issues = [];
-  let validItems = items.slice();
-  for (const rule of rules) {
-    if (validItems.length === 0) return { valid: [], issues };
-    const indicesToRemove = /* @__PURE__ */ new Set();
-    if (rule.kind === "single") {
-      for (let i = 0; i < validItems.length; i++) {
-        const item = validItems[i];
-        const issue = await rule.run(item, ctx);
-        if (issue) {
-          issues.push({ ...issue, ruleName: rule.name, item });
-          indicesToRemove.add(i);
-        }
-      }
-    } else if (rule.kind === "batch") {
-      const exec = async (slice, offset) => {
-        const map = await rule.run(slice, ctx);
-        for (let i = 0; i < slice.length; i++) {
-          const issue = map.get(i);
-          if (issue !== void 0) {
-            issues.push({ ...issue, ruleName: rule.name, item: slice[i] });
-            indicesToRemove.add(offset + i);
-          }
-        }
-      };
-      if (!chunkSize) await exec(validItems, 0);
-      else {
-        for (let i = 0; i < validItems.length; i += chunkSize) {
-          await exec(validItems.slice(i, i + chunkSize), i);
-        }
+var APIError = class extends Error {
+  constructor(statusCode, message, code, details) {
+    super(message);
+    this.statusCode = statusCode;
+    this.code = code;
+    this.details = details;
+    this.name = "APIError";
+  }
+};
+var ValidationError = class extends APIError {
+  constructor(message, details) {
+    super(400, message, "VALIDATION_ERROR", details);
+  }
+};
+var NotFoundError = class extends APIError {
+  constructor(message) {
+    super(404, message, "NOT_FOUND");
+  }
+};
+var InternalServerError = class extends APIError {
+  constructor(message = "Internal server error") {
+    super(500, message, "INTERNAL_SERVER_ERROR");
+  }
+};
+var BadRequestError = class extends APIError {
+  constructor(message = "Invalid JSON format", details) {
+    super(400, message, "BAD_REQUEST", details);
+  }
+};
+function handleZodError(error2) {
+  const formattedErrors = error2.issues.map((err) => {
+    const field = err.path.join(".");
+    let issue = err.message;
+    if (err.code === "invalid_type") {
+      if (err.message.includes("received undefined")) {
+        issue = `${field} is required`;
+      } else {
+        issue = err.message;
       }
+    } else if (err.code === "invalid_format") {
+      issue = `${field} has an invalid format`;
     }
-    validItems = validItems.filter((_, i) => !indicesToRemove.has(i));
-  }
-  return {
-    valid: validItems,
-    issues
-  };
+    return {
+      field,
+      issue
+    };
+  });
+  return new ValidationError("Validation failed", formattedErrors);
+}
+function handleAPIError(error2, c) {
+  return c.json({
+    statusCode: error2.statusCode,
+    body: JSON.stringify({
+      status: "error",
+      error: {
+        code: error2.code,
+        message: error2.message,
+        ...error2.details && typeof error2.details === "object" ? { details: error2.details } : {}
+      },
+      meta: {
+        timestamp: (/* @__PURE__ */ new Date()).toISOString()
+      }
+    })
+  });
 }
 
-// src/ValidationRule.ts
-var ValidationRule_exports = {};
-__export(ValidationRule_exports, {
-  batch: () => batch,
-  morpho: () => morpho,
-  single: () => single
+// src/core/Services.ts
+var Services_exports = {};
+__export(Services_exports, {
+  from: () => from2
 });
-function single(name, run2) {
-  return { kind: "single", name, run: run2 };
-}
-function batch(name, run2) {
-  return { kind: "batch", name, run: run2 };
-}
-function morpho() {
-  const chainId = single("chain_id", (offer, { chain }) => {
-    if (chain.id !== offer.chainId) {
-      return {
-        message: `Chain ID ${offer.chainId} is not the same as the chain ID in the context (${chain.id})`
-      };
-    }
+function from2(config) {
+  const { chain, rpcUrl, dbConfig } = config;
+  const walletClient = createWalletClient({
+    chain,
+    transport: http(rpcUrl)
+  }).extend(publicActions);
+  if (dbConfig.type === "pg" && !dbConfig.endpoint) {
+    throw new Error("dbOffer.endpoint is required when dbOffer.type is pg");
+  }
+  const DB = dbConfig.type === "pg" ? connect({ type: "pg", endpoint: dbConfig.endpoint }) : connect({ type: "pglite" });
+  const offerStore = create3({ db: DB });
+  const collectorBlockStore = create({
+    db: DB
   });
-  const loanToken = single("loan_token", (offer, { chain }) => {
-    const tokens = new Set(
-      Array.from(chain.whitelistedAssets.values()).map((a) => a.toLowerCase())
-    );
-    if (!tokens.has(offer.loanToken.toLowerCase())) {
-      return {
-        message: `Loan token ${offer.loanToken} is not whitelisted on chain ${offer.chainId}`
-      };
+  const liquidityStore = create2({ db: DB });
+  const interval = 1e4;
+  const maxBatchSize = 1e3;
+  const mempoolOffersCollector = createMempoolCollector({
+    mempool: Mempool.connect({
+      client: walletClient,
+      mempoolAddress: chain.mempool.address
+    }),
+    offerStore,
+    collectorBlockStore,
+    chain,
+    options: {
+      interval,
+      maxBatchSize
     }
   });
-  const expiry = single("expiry", (offer, _) => {
-    if (offer.expiry < Math.floor(Date.now() / 1e3)) {
-      return { message: "Expiry mismatch" };
+  const consumedEventsCollector = createConsumedEventsCollector({
+    client: walletClient,
+    contractAddress: chain.morpho,
+    offerStore,
+    collectorBlockStore,
+    chainId: chain.id,
+    options: {
+      interval,
+      maxBatchSize
     }
   });
-  const callback = single("empty_callback", (offer, _) => {
-    if (!offer.buy || offer.callback.data !== "0x") {
-      return { message: "Callback not supported yet." };
+  const buyWithEmptyCallbackLiquidityCollector = createBuyWithEmptyCallbackLiquidityCollector({
+    client: walletClient,
+    offerStore,
+    collectorBlockStore,
+    liquidityStore,
+    chain,
+    options: {
+      interval,
+      maxBatchSize
     }
   });
-  return [
-    chainId,
-    loanToken,
-    expiry,
-    // note: callback rule should be the last one, since it does not mean that the offer is forever invalid
-    // integrators should be able to choose if they want to keep the offer or not
-    callback
-  ];
+  return {
+    offerStore,
+    collectorBlockStore,
+    liquidityStore,
+    mempoolOffersCollector,
+    consumedEventsCollector,
+    buyWithEmptyCallbackLiquidityCollector,
+    DB
+  };
 }
 
-export { apiSchema_exports as ApiSchema, Callback_exports as Callback, Cursor_exports as Cursor, Liquidity_exports as Liquidity, Logger_exports as Logger, OfferStore_exports as OfferStore, router_exports as Router, RouterOffer_exports as RouterOffer, Validation_exports as Validation, ValidationRule_exports as ValidationRule };
+export { apiSchema_exports as ApiSchema, Callback_exports as Callback, Collector_exports as Collector, CollectorBlockStore_exports as CollectorBlockStore, Cursor_exports as Cursor, Liquidity_exports as Liquidity, LiquidityStore_exports as LiquidityStore, Logger_exports as Logger, OfferStore_exports as OfferStore, schema_exports as OffersSchema, PG_exports as PG, router_exports as Router, RouterOffer_exports as RouterOffer, Services_exports as Services, Validation_exports as Validation, ValidationRule_exports as ValidationRule };
 //# sourceMappingURL=index.node.mjs.map
 //# sourceMappingURL=index.node.mjs.map