@morpho-dev/router 0.1.6 → 0.1.7

package/dist/index.node.mjs

@@ -1,12 +1,22 @@
-import { Errors, LLTV, Offer, Format, Time, Maturity, Utils } from '@morpho-dev/mempool';
+import { Errors, LLTV, Utils, Offer, Format, Chain, Maturity, Time, Mempool } from '@morpho-dev/mempool';
 export * from '@morpho-dev/mempool';
-import { Base64 } from 'js-base64';
+import { parseUnits, publicActions, maxUint256, parseEventLogs, formatUnits, createWalletClient, http, erc20Abi } from 'viem';
+import { getBlockNumber } from 'viem/actions';
+import { AsyncLocalStorage } from 'async_hooks';
 import { z } from 'zod/v4';
+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 { Base64 } from 'js-base64';
 import { createDocument } from 'zod-openapi';
-import { parseUnits, maxUint256, formatUnits, erc20Abi } from 'viem';
 import { serve as serve$1 } from '@hono/node-server';
 import { Hono } from 'hono';
-import { AsyncLocalStorage } from 'async_hooks';
+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';
 
 var __defProp = Object.defineProperty;
 var __export = (target, all) => {
@@ -26,7 +36,7 @@ var CallbackType = /* @__PURE__ */ ((CallbackType2) => {
   return CallbackType2;
 })(CallbackType || {});
 function buildLiquidity(parameters) {
-  const { type, user, contract, chainId, amount, index = 0, updatedAt = /* @__PURE__ */ new Date() } = 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();
@@ -45,7 +55,7 @@ function buildLiquidity(parameters) {
         queue: {
           queueId: id,
           availableLiquidityPoolId: id,
-          index,
+          index: index2,
           updatedAt
         },
         pool: {
@@ -67,101 +77,436 @@ function getCallbackIdForOffer(offer) {
   return null;
 }
 
-// src/Cursor.ts
-var Cursor_exports = {};
-__export(Cursor_exports, {
-  decode: () => decode,
-  encode: () => encode,
-  validate: () => validate
+// src/Collector/index.ts
+var Collector_exports = {};
+__export(Collector_exports, {
+  createBuyWithEmptyCallbackLiquidityCollector: () => createBuyWithEmptyCallbackLiquidityCollector,
+  createChainReorgsCollector: () => createChainReorgsCollector,
+  createConsumedEventsCollector: () => createConsumedEventsCollector,
+  createMempoolCollector: () => createMempoolCollector,
+  start: () => start
 });
-function validate(cursor) {
-  if (!cursor || typeof cursor !== "object") {
-    throw new Error("Cursor must be an object");
-  }
-  const c = cursor;
-  if (!["rate", "maturity", "expiry", "amount"].includes(c.sort)) {
-    throw new Error(
-      `Invalid sort field: ${c.sort}. Must be one of: rate, maturity, expiry, amount`
-    );
-  }
-  if (!["asc", "desc"].includes(c.dir)) {
-    throw new Error(`Invalid direction: ${c.dir}. Must be one of: asc, desc`);
+
+// 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]
+      });
+    }
+    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 (!/^0x[a-fA-F0-9]{64}$/.test(c.hash)) {
-    throw new Error(
-      `Invalid hash format: ${c.hash}. Must be a 64-character hex string starting with 0x`
-    );
+  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
+        })
+      );
+    }
   }
-  const validations = {
-    rate: {
-      field: "rate",
-      type: "string",
-      pattern: /^\d+$/,
-      error: "numeric string"
-    },
-    amount: {
-      field: "assets",
-      type: "string",
-      pattern: /^\d+$/,
-      error: "numeric string"
-    },
-    maturity: {
-      field: "maturity",
-      type: "number",
-      validator: (val) => val > 0,
-      error: "positive number"
+  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)
     },
-    expiry: {
-      field: "expiry",
-      type: "number",
-      validator: (val) => val > 0,
-      error: "positive number"
-    }
+    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;
+      }
+    )
   };
-  const validation = validations[c.sort];
-  if (!validation) {
-    throw new Error(`Invalid sort field: ${c.sort}`);
-  }
-  const fieldValue = c[validation.field];
-  if (!fieldValue) {
-    throw new Error(`${c.sort} sort requires '${validation.field}' field to be present`);
-  }
-  if (typeof fieldValue !== validation.type) {
-    throw new Error(
-      `${c.sort} sort requires '${validation.field}' field of type ${validation.type}`
-    );
-  }
-  if (validation.pattern && !validation.pattern.test(fieldValue)) {
-    throw new Error(
-      `Invalid ${validation.field} format: ${fieldValue}. Must be a ${validation.error}`
-    );
-  }
-  if (validation.validator && !validation.validator(fieldValue)) {
-    throw new Error(
-      `Invalid ${validation.field} value: ${fieldValue}. Must be a ${validation.error}`
+  return JSON.stringify(normalized);
+}
+
+// src/Collector/BuyWithEmptyCallbackLiquidityCollector.ts
+function createBuyWithEmptyCallbackLiquidityCollector(params) {
+  const {
+    client,
+    collectorBlockStore,
+    liquidityStore,
+    offerStore,
+    chain,
+    options: { maxBatchSize, interval } = {}
+  } = params;
+  const collectorName = "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
+        }
+      });
+      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) => {
+    return Utils.poll(
+      async () => {
+        const publicClient = client.extend(publicActions);
+        const pairs = await getUniqueUserTokenPairs();
+        const latestBlockNumber = await getBlockNumber(publicClient);
+        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: Number(latestBlockNumber),
+            batchSize: maxBatchSize
+          }
+        });
+        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,
+          chainId: chain.id,
+          blockNumber: Number(latestBlockNumber)
+        });
+        emit(Number(latestBlockNumber));
+      },
+      { interval: interval ?? 3e4 }
     );
-  }
-  return true;
+  });
+  const onReorg = (_lastFinalizedBlockNumber) => {
+  };
+  return {
+    name: collectorName,
+    lastSyncedBlock: async () => await collectorBlockStore.getBlockNumber({ collectorName, chainId: chain.id }),
+    collect,
+    onReorg
+  };
 }
-function encode(c) {
-  return Base64.encodeURL(JSON.stringify(c));
+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;
+    }
+    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
+    });
+  };
+  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: (_) => {
+    }
+  };
 }
-function decode(token) {
-  if (!token) return null;
-  const decoded = JSON.parse(Base64.decode(token));
-  validate(decoded);
-  return decoded;
+
+// src/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;
+  };
 }
 
-// src/core/apiSchema/index.ts
-var apiSchema_exports = {};
-__export(apiSchema_exports, {
-  OpenApi: () => OpenApi,
-  fromResponse: () => fromResponse,
-  parse: () => parse,
-  safeParse: () => safeParse,
-  toResponse: () => toResponse
+// 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) : () => {
+    }
+  };
+}
+function silentLogger() {
+  return {
+    trace: () => {
+    },
+    debug: () => {
+    },
+    info: () => {
+    },
+    warn: () => {
+    },
+    error: () => {
+    },
+    fatal: () => {
+    }
+  };
+}
+var loggerContext = new AsyncLocalStorage();
+function runWithLogger(logger, fn) {
+  return loggerContext.run(logger, fn);
+}
+function getLogger() {
+  return loggerContext.getStore() ?? defaultLogger();
+}
 
 // src/RouterOffer.ts
 var RouterOffer_exports = {};
@@ -243,158 +588,715 @@ var InvalidRouterOfferError = class extends Errors.BaseError {
   }
 };
 
-// src/core/apiSchema/requests.ts
-var MAX_LIMIT = 100;
-var DEFAULT_LIMIT = 20;
-var MAX_LLTV = 100;
-var MIN_LLTV = 0;
-var GetOffersQueryParams = z.object({
-  // Core filtering parameters
-  creators: z.string().regex(/^0x[a-fA-F0-9]{40}(,0x[a-fA-F0-9]{40})*$/, {
-    message: "Creators must be comma-separated Ethereum addresses"
-  }).transform((val) => val.split(",").map((addr) => addr.toLowerCase())).optional().meta({
-    description: "Filter by multiple creator addresses (comma-separated)",
-    example: "0x1234567890123456789012345678901234567890,0xabcdefabcdefabcdefabcdefabcdefabcdefabcd"
-  }),
-  side: z.enum(["buy", "sell"]).optional().meta({
-    description: "Filter by offer type: buy offers or sell offers",
-    example: "buy"
-  }),
-  chains: z.string().regex(/^\d+(,\d+)*$/, {
-    message: "Chains must be comma-separated chain IDs"
-  }).transform((val) => val.split(",").map(Number)).optional().meta({
-    description: "Filter by multiple blockchain networks (comma-separated chain IDs)",
-    example: "1,137,10"
-  }),
-  loan_tokens: z.string().regex(/^0x[a-fA-F0-9]{40}(,0x[a-fA-F0-9]{40})*$/, {
-    message: "Loan assets must be comma-separated Ethereum addresses"
-  }).transform((val) => val.split(",").map((addr) => addr.toLowerCase())).optional().meta({
-    description: "Filter by multiple loan assets (comma-separated)",
-    example: "0x1234567890123456789012345678901234567890,0xabcdefabcdefabcdefabcdefabcdefabcdefabcd"
-  }),
-  status: z.string().regex(/^[a-zA-Z_]+(,[a-zA-Z_]+)*$/, {
-    message: "Status must be comma-separated status values"
-  }).transform((val) => val.split(",")).refine((statuses) => statuses.every((status) => OfferStatusValues.includes(status)), {
-    message: `Invalid status value. Must be one of: ${OfferStatusValues.join(", ")}`
-  }).optional().meta({
-    description: `Filter by multiple statuses (comma-separated). Valid values: ${OfferStatusValues.join(", ")}. By default, only offers with 'valid' status are returned.`,
-    example: "valid,callback_error"
-  }),
-  callback_addresses: z.string().regex(/^0x[a-fA-F0-9]{40}(,0x[a-fA-F0-9]{40})*$/, {
-    message: "Callback addresses must be comma-separated Ethereum addresses"
-  }).transform((val) => val.split(",").map((addr) => addr.toLowerCase())).optional().meta({
-    description: "Filter by multiple callback addresses (comma-separated)",
-    example: "0x1234567890123456789012345678901234567890,0xabcdefabcdefabcdefabcdefabcdefabcdefabcd"
-  }),
-  // Asset range
-  min_amount: z.bigint({ coerce: true }).positive({
-    message: "Min amount must be a positive number"
-  }).optional().meta({
-    description: "Minimum amount of assets in the offer",
-    example: "1000"
-  }),
-  max_amount: z.bigint({ coerce: true }).positive({
-    message: "Max amount must be a positive number"
-  }).optional().meta({
-    description: "Maximum amount of assets in the offer",
-    example: "10000"
-  }),
-  // Rate range
-  min_rate: z.bigint({ coerce: true }).positive({
-    message: "Min rate must be a positive number"
-  }).optional().meta({
-    description: "Minimum rate per asset (in wei)",
-    example: "500000000000000000"
-  }),
-  max_rate: z.bigint({ coerce: true }).positive({
-    message: "Max rate must be a positive number"
-  }).optional().meta({
-    description: "Maximum rate per asset (in wei)",
-    example: "1500000000000000000"
-  }),
-  // Time range
-  min_maturity: z.coerce.number().int().min(0).optional().meta({
-    description: "Minimum maturity timestamp (Unix timestamp in seconds)",
-    example: "1700000000"
-  }),
-  max_maturity: z.coerce.number().int().min(0).optional().meta({
-    description: "Maximum maturity timestamp (Unix timestamp in seconds)",
-    example: "1800000000"
-  }),
-  min_expiry: z.coerce.number().int().optional().meta({
-    description: "Minimum expiry timestamp (Unix timestamp in seconds)",
-    example: "1700000000"
-  }),
-  max_expiry: z.coerce.number().int().optional().meta({
-    description: "Maximum expiry timestamp (Unix timestamp in seconds)",
-    example: "1800000000"
-  }),
-  // Collateral filtering
-  collateral_assets: z.string().regex(/^0x[a-fA-F0-9]{40}(,0x[a-fA-F0-9]{40})*$/, {
-    message: "Collateral assets must be comma-separated Ethereum addresses"
-  }).transform((val) => val.split(",").map((addr) => addr.toLowerCase())).optional().meta({
-    description: "Filter by multiple collateral assets (comma-separated)",
-    example: "0x1234567890123456789012345678901234567890,0xabcdefabcdefabcdefabcdefabcdefabcdefabcd"
-  }),
-  collateral_oracles: z.string().regex(/^0x[a-fA-F0-9]{40}(,0x[a-fA-F0-9]{40})*$/, {
-    message: "Collateral oracles must be comma-separated Ethereum addresses"
-  }).transform((val) => val.split(",").map((addr) => addr.toLowerCase())).optional().meta({
-    description: "Filter by multiple rate oracles (comma-separated)",
-    example: "0x1234567890123456789012345678901234567890,0xabcdefabcdefabcdefabcdefabcdefabcdefabcd"
-  }),
-  collateral_tuple: z.string().transform((val, ctx) => {
-    const pattern = /^(0x[a-fA-F0-9]{40}(:0x[a-fA-F0-9]{40})?(:[0-9]+(\.[0-9]+)?)?)(#0x[a-fA-F0-9]{40}(:0x[a-fA-F0-9]{40})?(:[0-9]+(\.[0-9]+)?)?)*$/;
-    if (!pattern.test(val)) {
-      ctx.addIssue({
-        code: "custom",
-        message: "collateral_tuple has an invalid format",
-        input: val
-      });
-    }
-    return val.split("#").map((tuple) => {
-      const parts = tuple.split(":");
-      if (parts.length === 0 || !parts[0]) {
-        ctx.addIssue({
-          code: "custom",
-          message: "Asset address is required for each collateral tuple",
-          path: ["asset"],
-          input: val
+// src/Collector/ConsumedEventsCollector.ts
+function createConsumedEventsCollector(parameters) {
+  const {
+    client,
+    contractAddress,
+    offerStore,
+    collectorBlockStore,
+    options: { maxBatchSize, interval } = {},
+    chainId
+  } = parameters;
+  const logger = getLogger();
+  const collectorName = "consumed_events";
+  const collect = Utils.lazy((emit) => {
+    return Utils.poll(
+      async () => {
+        const lastSyncedBlock = await collectorBlockStore.getBlockNumber({
+          collectorName,
+          chainId
         });
-        return z.NEVER;
-      }
-      const asset = parts[0]?.toLowerCase();
-      const oracle = parts[1]?.toLowerCase();
-      const lltv = parts[2] ? parseFloat(parts[2]) : void 0;
-      if (lltv !== void 0 && (lltv < MIN_LLTV || lltv > MAX_LLTV)) {
-        ctx.addIssue({
-          code: "custom",
-          message: `LLTV must be between ${MIN_LLTV} and ${MAX_LLTV} (0-100%)`,
-          path: ["lltv"],
-          input: val
+        const stream = Chain.streamLogs({
+          client,
+          contractAddress,
+          event: consumedEvent,
+          blockNumberGte: lastSyncedBlock,
+          order: "asc",
+          options: { maxBatchSize }
         });
-        return z.NEVER;
-      }
-      let lltvValue;
-      if (lltv !== void 0) {
-        try {
-          lltvValue = LLTV.from(parseUnits(lltv.toString(), 16));
-        } catch (e) {
-          ctx.issues.push({
-            code: "custom",
-            message: e instanceof LLTV.InvalidLLTVError || e instanceof LLTV.InvalidOptionError ? e.message : "Invalid LLTV.",
-            input: lltv,
-            path: ["lltv"]
-          });
-          return z.NEVER;
+        for await (const logs of stream) {
+          if (logs.length === 0) break;
+          const parsedLogs = parseEventLogs({ abi: [consumedEvent], logs });
+          const offersConsumed = [];
+          for (const log of parsedLogs) {
+            offersConsumed.push(
+              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
+              })
+            );
+          }
+          try {
+            for (const offerConsumed of offersConsumed) {
+              logger.debug?.("updating consumed amount", { offerConsumed });
+              await offerStore.updateConsumedAmount({
+                id: offerConsumed.id,
+                chainId: offerConsumed.chainId,
+                offering: offerConsumed.offering,
+                nonce: offerConsumed.nonce,
+                consumed: offerConsumed.amount
+              });
+            }
+            const lastBlockNumber = Number(logs[logs.length - 1]?.blockNumber);
+            await collectorBlockStore.saveBlockNumber({
+              collectorName: "consumed_events",
+              chainId,
+              blockNumber: lastBlockNumber
+            });
+            emit(lastBlockNumber);
+          } catch (err) {
+            logger.error({ err }, "Failed to process offer_consumed events");
+          }
+        }
+      },
+      { interval: interval ?? 3e4 }
+    );
+  });
+  const onReorg = (_lastFinalizedBlockNumber) => {
+  };
+  return {
+    name: collectorName,
+    lastSyncedBlock: async () => await collectorBlockStore.getBlockNumber({ collectorName, chainId }),
+    onReorg,
+    collect
+  };
+}
+
+// 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);
         }
       }
-      return {
-        asset,
-        oracle,
-        lltv: lltvValue
-      };
-    });
-  }).optional().meta({
+    } 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));
+  }
+  return {
+    valid: validItems,
+    issues
+  };
+}
+
+// src/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/Collector/MempoolCollector.ts
+function createMempoolCollector(parameters) {
+  const logger = getLogger();
+  const {
+    mempool,
+    offerStore,
+    collectorBlockStore,
+    chain,
+    options: { maxBatchSize, interval } = {}
+  } = parameters;
+  const collectorName = "mempool_offers";
+  const collect = Utils.lazy((emit) => {
+    return mempool.watch({
+      lastSyncedBlock: async () => await collectorBlockStore.getBlockNumber({ collectorName, chainId: chain.id }),
+      polling: { maxBatchSize, interval },
+      onOffers: async (offers2, blockNumber) => {
+        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 },
+            "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,
+          chainId: chain.id,
+          blockNumber
+        });
+        emit(blockNumber);
+      }
+    });
+  });
+  const onReorg = (_lastFinalizedBlockNumber) => {
+  };
+  return {
+    name: collectorName,
+    lastSyncedBlock: async () => await collectorBlockStore.getBlockNumber({ collectorName, chainId: chain.id }),
+    collect,
+    onReorg
+  };
+}
+
+// src/CollectorBlockStore.ts
+var CollectorBlockStore_exports = {};
+__export(CollectorBlockStore_exports, {
+  create: () => create,
+  memory: () => memory
+});
+
+// src/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/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()
+        }
+      });
+    }
+  };
+};
+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);
+    }
+  };
+}
+
+// src/Cursor.ts
+var Cursor_exports = {};
+__export(Cursor_exports, {
+  decode: () => decode,
+  encode: () => encode,
+  validate: () => validate
+});
+function validate(cursor) {
+  if (!cursor || typeof cursor !== "object") {
+    throw new Error("Cursor must be an object");
+  }
+  const c = cursor;
+  if (!["rate", "maturity", "expiry", "amount"].includes(c.sort)) {
+    throw new Error(
+      `Invalid sort field: ${c.sort}. Must be one of: rate, maturity, expiry, amount`
+    );
+  }
+  if (!["asc", "desc"].includes(c.dir)) {
+    throw new Error(`Invalid direction: ${c.dir}. Must be one of: asc, desc`);
+  }
+  if (!/^0x[a-fA-F0-9]{64}$/.test(c.hash)) {
+    throw new Error(
+      `Invalid hash format: ${c.hash}. Must be a 64-character hex string starting with 0x`
+    );
+  }
+  const validations = {
+    rate: {
+      field: "rate",
+      type: "string",
+      pattern: /^\d+$/,
+      error: "numeric string"
+    },
+    amount: {
+      field: "assets",
+      type: "string",
+      pattern: /^\d+$/,
+      error: "numeric string"
+    },
+    maturity: {
+      field: "maturity",
+      type: "number",
+      validator: (val) => val > 0,
+      error: "positive number"
+    },
+    expiry: {
+      field: "expiry",
+      type: "number",
+      validator: (val) => val > 0,
+      error: "positive number"
+    }
+  };
+  const validation = validations[c.sort];
+  if (!validation) {
+    throw new Error(`Invalid sort field: ${c.sort}`);
+  }
+  const fieldValue = c[validation.field];
+  if (!fieldValue) {
+    throw new Error(`${c.sort} sort requires '${validation.field}' field to be present`);
+  }
+  if (typeof fieldValue !== validation.type) {
+    throw new Error(
+      `${c.sort} sort requires '${validation.field}' field of type ${validation.type}`
+    );
+  }
+  if (validation.pattern && !validation.pattern.test(fieldValue)) {
+    throw new Error(
+      `Invalid ${validation.field} format: ${fieldValue}. Must be a ${validation.error}`
+    );
+  }
+  if (validation.validator && !validation.validator(fieldValue)) {
+    throw new Error(
+      `Invalid ${validation.field} value: ${fieldValue}. Must be a ${validation.error}`
+    );
+  }
+  return true;
+}
+function encode(c) {
+  return Base64.encodeURL(JSON.stringify(c));
+}
+function decode(token) {
+  if (!token) return null;
+  const decoded = JSON.parse(Base64.decode(token));
+  validate(decoded);
+  return decoded;
+}
+
+// src/core/apiSchema/index.ts
+var apiSchema_exports = {};
+__export(apiSchema_exports, {
+  OpenApi: () => OpenApi,
+  fromResponse: () => fromResponse,
+  parse: () => parse,
+  safeParse: () => safeParse,
+  toResponse: () => toResponse
+});
+var MAX_LIMIT = 100;
+var DEFAULT_LIMIT = 20;
+var MAX_LLTV = 100;
+var MIN_LLTV = 0;
+var GetOffersQueryParams = z.object({
+  // Core filtering parameters
+  creators: z.string().regex(/^0x[a-fA-F0-9]{40}(,0x[a-fA-F0-9]{40})*$/, {
+    message: "Creators must be comma-separated Ethereum addresses"
+  }).transform((val) => val.split(",").map((addr) => addr.toLowerCase())).optional().meta({
+    description: "Filter by multiple creator addresses (comma-separated)",
+    example: "0x1234567890123456789012345678901234567890,0xabcdefabcdefabcdefabcdefabcdefabcdefabcd"
+  }),
+  side: z.enum(["buy", "sell"]).optional().meta({
+    description: "Filter by offer type: buy offers or sell offers",
+    example: "buy"
+  }),
+  chains: z.string().regex(/^\d+(,\d+)*$/, {
+    message: "Chains must be comma-separated chain IDs"
+  }).transform((val) => val.split(",").map(Number)).optional().meta({
+    description: "Filter by multiple blockchain networks (comma-separated chain IDs)",
+    example: "1,137,10"
+  }),
+  loan_tokens: z.string().regex(/^0x[a-fA-F0-9]{40}(,0x[a-fA-F0-9]{40})*$/, {
+    message: "Loan assets must be comma-separated Ethereum addresses"
+  }).transform((val) => val.split(",").map((addr) => addr.toLowerCase())).optional().meta({
+    description: "Filter by multiple loan assets (comma-separated)",
+    example: "0x1234567890123456789012345678901234567890,0xabcdefabcdefabcdefabcdefabcdefabcdefabcd"
+  }),
+  status: z.string().regex(/^[a-zA-Z_]+(,[a-zA-Z_]+)*$/, {
+    message: "Status must be comma-separated status values"
+  }).transform((val) => val.split(",")).refine((statuses) => statuses.every((status) => OfferStatusValues.includes(status)), {
+    message: `Invalid status value. Must be one of: ${OfferStatusValues.join(", ")}`
+  }).optional().meta({
+    description: `Filter by multiple statuses (comma-separated). Valid values: ${OfferStatusValues.join(", ")}. By default, only offers with 'valid' status are returned.`,
+    example: "valid,callback_error"
+  }),
+  callback_addresses: z.string().regex(/^0x[a-fA-F0-9]{40}(,0x[a-fA-F0-9]{40})*$/, {
+    message: "Callback addresses must be comma-separated Ethereum addresses"
+  }).transform((val) => val.split(",").map((addr) => addr.toLowerCase())).optional().meta({
+    description: "Filter by multiple callback addresses (comma-separated)",
+    example: "0x1234567890123456789012345678901234567890,0xabcdefabcdefabcdefabcdefabcdefabcdefabcd"
+  }),
+  // Asset range
+  min_amount: z.bigint({ coerce: true }).positive({
+    message: "Min amount must be a positive number"
+  }).optional().meta({
+    description: "Minimum amount of assets in the offer",
+    example: "1000"
+  }),
+  max_amount: z.bigint({ coerce: true }).positive({
+    message: "Max amount must be a positive number"
+  }).optional().meta({
+    description: "Maximum amount of assets in the offer",
+    example: "10000"
+  }),
+  // Rate range
+  min_rate: z.bigint({ coerce: true }).positive({
+    message: "Min rate must be a positive number"
+  }).optional().meta({
+    description: "Minimum rate per asset (in wei)",
+    example: "500000000000000000"
+  }),
+  max_rate: z.bigint({ coerce: true }).positive({
+    message: "Max rate must be a positive number"
+  }).optional().meta({
+    description: "Maximum rate per asset (in wei)",
+    example: "1500000000000000000"
+  }),
+  // Time range
+  min_maturity: z.coerce.number().int().min(0).optional().meta({
+    description: "Minimum maturity timestamp (Unix timestamp in seconds)",
+    example: "1700000000"
+  }),
+  max_maturity: z.coerce.number().int().min(0).optional().meta({
+    description: "Maximum maturity timestamp (Unix timestamp in seconds)",
+    example: "1800000000"
+  }),
+  min_expiry: z.coerce.number().int().optional().meta({
+    description: "Minimum expiry timestamp (Unix timestamp in seconds)",
+    example: "1700000000"
+  }),
+  max_expiry: z.coerce.number().int().optional().meta({
+    description: "Maximum expiry timestamp (Unix timestamp in seconds)",
+    example: "1800000000"
+  }),
+  // Collateral filtering
+  collateral_assets: z.string().regex(/^0x[a-fA-F0-9]{40}(,0x[a-fA-F0-9]{40})*$/, {
+    message: "Collateral assets must be comma-separated Ethereum addresses"
+  }).transform((val) => val.split(",").map((addr) => addr.toLowerCase())).optional().meta({
+    description: "Filter by multiple collateral assets (comma-separated)",
+    example: "0x1234567890123456789012345678901234567890,0xabcdefabcdefabcdefabcdefabcdefabcdefabcd"
+  }),
+  collateral_oracles: z.string().regex(/^0x[a-fA-F0-9]{40}(,0x[a-fA-F0-9]{40})*$/, {
+    message: "Collateral oracles must be comma-separated Ethereum addresses"
+  }).transform((val) => val.split(",").map((addr) => addr.toLowerCase())).optional().meta({
+    description: "Filter by multiple rate oracles (comma-separated)",
+    example: "0x1234567890123456789012345678901234567890,0xabcdefabcdefabcdefabcdefabcdefabcdefabcd"
+  }),
+  collateral_tuple: z.string().transform((val, ctx) => {
+    const pattern = /^(0x[a-fA-F0-9]{40}(:0x[a-fA-F0-9]{40})?(:[0-9]+(\.[0-9]+)?)?)(#0x[a-fA-F0-9]{40}(:0x[a-fA-F0-9]{40})?(:[0-9]+(\.[0-9]+)?)?)*$/;
+    if (!pattern.test(val)) {
+      ctx.addIssue({
+        code: "custom",
+        message: "collateral_tuple has an invalid format",
+        input: val
+      });
+    }
+    return val.split("#").map((tuple) => {
+      const parts = tuple.split(":");
+      if (parts.length === 0 || !parts[0]) {
+        ctx.addIssue({
+          code: "custom",
+          message: "Asset address is required for each collateral tuple",
+          path: ["asset"],
+          input: val
+        });
+        return z.NEVER;
+      }
+      const asset = parts[0]?.toLowerCase();
+      const oracle = parts[1]?.toLowerCase();
+      const lltv = parts[2] ? parseFloat(parts[2]) : void 0;
+      if (lltv !== void 0 && (lltv < MIN_LLTV || lltv > MAX_LLTV)) {
+        ctx.addIssue({
+          code: "custom",
+          message: `LLTV must be between ${MIN_LLTV} and ${MAX_LLTV} (0-100%)`,
+          path: ["lltv"],
+          input: val
+        });
+        return z.NEVER;
+      }
+      let lltvValue;
+      if (lltv !== void 0) {
+        try {
+          lltvValue = LLTV.from(parseUnits(lltv.toString(), 16));
+        } catch (e) {
+          ctx.issues.push({
+            code: "custom",
+            message: e instanceof LLTV.InvalidLLTVError || e instanceof LLTV.InvalidOptionError ? e.message : "Invalid LLTV.",
+            input: lltv,
+            path: ["lltv"]
+          });
+          return z.NEVER;
+        }
+      }
+      return {
+        asset,
+        oracle,
+        lltv: lltvValue
+      };
+    });
+  }).optional().meta({
     description: "Filter by collateral combinations in format: asset:oracle:lltv#asset2:oracle2:lltv2. Oracle and lltv are optional. Use # to separate multiple combinations.",
     example: "0x1234567890123456789012345678901234567890:0xabcdefabcdefabcdefabcdefabcdefabcdefabcd:86#0x9876543210987654321098765432109876543210:94.5"
   }),
@@ -740,19 +1642,19 @@ 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
   };
@@ -878,8 +1780,8 @@ async function get(config, parameters) {
   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);
+  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)
@@ -920,8 +1822,8 @@ async function match(config, parameters) {
   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);
+  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)
@@ -933,501 +1835,87 @@ async function getApi(config, url) {
   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 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
-  });
-  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 response.json();
-}
-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]
-    });
-  }
-};
-
-// src/OfferStore/index.ts
-var OfferStore_exports = {};
-__export(OfferStore_exports, {
-  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);
-  };
-  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;
-    }
-    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;
-        }
-        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;
-        }
-        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;
-        }
-        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;
-        }
-        return sortOrder === "asc" ? a.expiry > b.expiry ? 1 : -1 : b.expiry > a.expiry ? 1 : -1;
-    }
-  };
-  return {
-    create,
-    createMany: async (parameters2) => {
-      return Promise.all(
-        parameters2.map((p) => create({ offer: p.offer, status: p.status, metadata: p.metadata }))
-      );
-    },
-    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 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");
-        }
-        switch (cursor.sort) {
-          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;
-          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;
-          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;
-          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;
-          default:
-            throw new Error("Invalid sort parameter");
-        }
-        offers = offers.filter((o) => o.hash !== 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)
-          )
-        )
-      ));
-      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));
-      let nextCursor = null;
-      if (offers.length > limit) {
-        const last = offers[limit - 1];
-        const base = {
-          sort: sortBy,
-          dir: sortOrder,
-          hash: last.hash
-        };
-        switch (sortBy) {
-          case "rate":
-            base.rate = last.rate.toString();
-            break;
-          case "amount":
-            base.assets = last.assets.toString();
-            break;
-          case "maturity":
-            base.maturity = last.maturity;
-            break;
-          default:
-            base.expiry = last.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())),
-          callback: {
-            address: o.callback.address,
-            data: o.callback.data,
-            gasLimit: o.callback.gasLimit
-          },
-          ...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
-      };
-    },
-    findMatchingOffers: async (params) => {
-      const {
-        side,
-        chainId,
-        rate,
-        collaterals = [],
-        maturity,
-        minMaturity,
-        maxMaturity,
-        loanToken,
-        creator,
-        cursor: queryCursor,
-        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) {
-          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
-            );
-          })
-        )
-      ));
-      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;
-        }
-        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;
-        }
-        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));
-      let nextCursor = null;
-      if (offers.length > limit) {
-        const last = offers[limit - 1];
-        nextCursor = encode({
-          sort: "rate",
-          dir: sortOrder,
-          hash: last.hash,
-          rate: last.rate.toString()
-        });
-      }
-      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())),
-          callback: {
-            address: o.callback.address,
-            data: o.callback.data,
-            gasLimit: o.callback.gasLimit
-          },
-          ...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
-      };
-    },
-    delete: async (hash) => {
-      if (!map.has(hash.toLowerCase())) return false;
-      map.delete(hash.toLowerCase());
-      return true;
-    },
-    deleteMany: async (hashes) => {
-      let deleted = 0;
-      for (const hash of hashes) {
-        if (map.has(hash.toLowerCase())) {
-          map.delete(hash.toLowerCase());
-          deleted++;
-        }
-      }
-      return deleted;
-    },
-    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
+      break;
+    case pathname.includes("/v1/offers"):
+      action = "get_offers";
+      break;
+    default:
+      throw new HttpGetOffersFailedError("Unknown endpoint", {
+        details: `Unsupported path: ${pathname}`
       });
-    },
-    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);
+  }
+  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
+  });
+  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 response.json();
 }
-
-// src/core/router/Server.ts
+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 ? parameters.store : memory({
-    offers: /* @__PURE__ */ new Map(),
-    filled: /* @__PURE__ */ new Map()
-  });
+  const store = parameters.store;
   app.get("/v1/offers", async (c) => {
     try {
       const params = parse("get_offers", c.req.query());
-      const offers = await store.getAll({
+      const offers2 = await store.getAll({
         query: {
           creators: params.creators,
           side: params.side,
@@ -1455,10 +1943,10 @@ async function serve(parameters) {
         }
       });
       return success(c, {
-        data: offers.offers.map(
+        data: offers2.offers.map(
           (offer) => Format.stringifyBigint(Format.toSnakeCase(toResponse(offer)))
         ),
-        cursor: offers.nextCursor ?? null
+        cursor: offers2.nextCursor ?? null
       });
     } catch (err) {
       console.error(err);
@@ -1468,7 +1956,7 @@ async function serve(parameters) {
   app.get("/v1/offers/match", async (c) => {
     try {
       const params = parse("match_offers", c.req.query());
-      const offers = await store.findMatchingOffers({
+      const offers2 = await store.findMatchingOffers({
         side: params.side,
         chainId: params.chain_id,
         rate: params.rate,
@@ -1482,10 +1970,10 @@ async function serve(parameters) {
         limit: params.limit
       });
       return success(c, {
-        data: offers.offers.map(
+        data: offers2.offers.map(
           (offer) => Format.stringifyBigint(Format.toSnakeCase(toResponse(offer)))
         ),
-        cursor: offers.nextCursor ?? null
+        cursor: offers2.nextCursor ?? null
       });
     } catch (err) {
       console.error(err);
@@ -1593,310 +2081,1018 @@ function handleAPIError(error2, c) {
   });
 }
 
-// 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]
-      });
-    }
-    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 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
-        })
-      );
-    }
-  }
-  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);
-}
-
-// src/Logger.ts
-var Logger_exports = {};
-__export(Logger_exports, {
-  LogLevelValues: () => LogLevelValues,
-  defaultLogger: () => defaultLogger,
-  getLogger: () => getLogger,
-  runWithLogger: () => runWithLogger,
-  silentLogger: () => silentLogger
+// src/LiquidityStore.ts
+var LiquidityStore_exports = {};
+__export(LiquidityStore_exports, {
+  create: () => create2,
+  memory: () => memory2
 });
-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];
+var create2 = (config) => {
+  const db = config.db;
   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) : () => {
+    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 };
     },
-    // biome-ignore lint/suspicious/noConsole: console is used for logging
-    error: isEnabled("error") ? console.error.bind(console) : () => {
+    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: [] });
+        }
+        byUserPosition.get(id).queues.push({ queue: row.queue, pool: row.pool });
+      }
+      return Array.from(byUserPosition.values());
     },
-    fatal: isEnabled("fatal") ? (...args) => console.error("[fatal]", ...args) : () => {
+    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()
+            }
+          });
+        }
+        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()
+            }
+          });
+        }
+        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 silentLogger() {
+};
+function memory2() {
+  const poolsById = /* @__PURE__ */ new Map();
+  const queuesByComposite = /* @__PURE__ */ new Map();
+  const queueIndexByQueueId = /* @__PURE__ */ new Map();
+  const userPositionsById = /* @__PURE__ */ new Map();
   return {
-    trace: () => {
-    },
-    debug: () => {
-    },
-    info: () => {
-    },
-    warn: () => {
+    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 };
     },
-    error: () => {
+    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 });
+        }
+        results.push({ userPosition: up, queues });
+      }
+      return results;
     },
-    fatal: () => {
+    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()
+      });
     }
   };
 }
-var loggerContext = new AsyncLocalStorage();
-function runWithLogger(logger, fn) {
-  return loggerContext.run(logger, fn);
-}
-function getLogger() {
-  return loggerContext.getStore() ?? defaultLogger();
-}
 
-// src/Validation.ts
-var Validation_exports = {};
-__export(Validation_exports, {
-  run: () => run
+// src/OfferStore/index.ts
+var OfferStore_exports = {};
+__export(OfferStore_exports, {
+  create: () => create3
 });
-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);
+function create3(config) {
+  const db = config.db;
+  return {
+    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 ?? {};
+      const conditions = [];
+      const now = Time.now();
+      if (query?.creators && query.creators.length > 0) {
+        conditions.push(
+          inArray(
+            offers.offering,
+            query.creators.map((c) => c.toLowerCase())
+          )
+        );
       }
-    } 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 (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})`);
         }
-      };
-      if (!chunkSize) await exec(validItems, 0);
-      else {
-        for (let i = 0; i < validItems.length; i += chunkSize) {
-          await exec(validItems.slice(i, i + chunkSize), i);
+      }
+      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":
+            return offers.rate;
+          case "maturity":
+            return offers.maturity;
+          case "expiry":
+            return offers.expiry;
+          case "amount":
+            return offers.assets;
+          default:
+            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");
+        }
+        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})`);
+      }
+      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`
+        )
+      ).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 (results.length === limit && results.length > 0) {
+        const lastRow = results[results.length - 1];
+        const base = {
+          sort: sortBy,
+          dir: sortOrder,
+          hash: lastRow.hash
+        };
+        switch (sortBy) {
+          case "rate":
+            base.rate = lastRow.rate.toString();
+            break;
+          case "amount":
+            base.assets = lastRow.assets.toString();
+            break;
+          case "maturity":
+            base.maturity = lastRow.maturity;
+            break;
+          default:
+            base.expiry = lastRow.expiry;
+        }
+        nextCursor = encode(base);
+      }
+      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: offerData.callbackAddress,
+            data: offerData.callbackData,
+            gasLimit: offerData.callbackGasLimit
+          },
+          ...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,
+        chainId,
+        rate,
+        collaterals = [],
+        maturity,
+        minMaturity,
+        maxMaturity,
+        loanToken,
+        creator,
+        cursor,
+        limit = 20
+      } = params;
+      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");
+        }
+      }
+      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)
+        )
+      ).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
+        }
+      ).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);
         }
+        return map;
+      };
+      const allEntries = Array.from(buildOffersMap(withCollats).values());
+      const pageEntries = allEntries.slice(0, limit);
+      let nextCursor = null;
+      if (allEntries.length > limit) {
+        const last = pageEntries[pageEntries.length - 1].base;
+        nextCursor = encode({
+          sort: "rate",
+          dir: rateSortDirection,
+          hash: last.hash,
+          rate: last.rate.toString()
+        });
+      }
+      const data = pageEntries.map(({ base, collaterals: cols }) => ({
+        ...Offer.from({
+          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: base.callbackAddress,
+            data: base.callbackData,
+            gasLimit: base.callbackGasLimit
+          },
+          ...base.signature !== null ? { signature: base.signature } : void 0
+        }),
+        consumed: BigInt(base.consumed),
+        status: base.status,
+        ...base.metadata ? { metadata: base.metadata } : {}
+      }));
+      return { offers: data, nextCursor };
+    },
+    delete: async (hash) => {
+      const result = await db.delete(offers).where(eq(offers.hash, hash.toLowerCase()));
+      return result.affectedRows > 0;
+    },
+    deleteMany: async (hashes) => {
+      if (hashes.length === 0) {
+        return 0;
       }
+      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 (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 (parameters) => {
+      await db.insert(consumed).values({
+        id: parameters.id,
+        chainId: parameters.chainId,
+        offering: parameters.offering.toLowerCase(),
+        nonce: parameters.nonce,
+        consumed: parameters.consumed.toString()
+      }).onConflictDoNothing();
     }
-    validItems = validItems.filter((_, i) => !indicesToRemove.has(i));
-  }
-  return {
-    valid: validItems,
-    issues
   };
 }
 
-// src/ValidationRule.ts
-var ValidationRule_exports = {};
-__export(ValidationRule_exports, {
-  batch: () => batch,
-  morpho: () => morpho,
-  single: () => single
+// src/OfferStore/PG.ts
+var PG_exports = {};
+__export(PG_exports, {
+  applyMigrations: () => applyMigrations,
+  clean: () => clean,
+  connect: () => connect2
 });
-function single(name, run2) {
-  return { kind: "single", name, run: run2 };
+function connect2(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 batch(name, run2) {
-  return { kind: "batch", name, run: run2 };
+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 });
 }
-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})`
-      };
-    }
+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/Services.ts
+var Services_exports = {};
+__export(Services_exports, {
+  from: () => from2
+});
+var from2 = async (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" ? connect2({ type: "pg", endpoint: dbConfig.endpoint }) : connect2({ 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 mempoolOffersCollector = createMempoolCollector({
+    mempool: Mempool.connect({
+      client: walletClient,
+      mempoolAddress: chain.mempool.address
+    }),
+    offerStore,
+    collectorBlockStore,
+    chain,
+    options: {
+      interval: 1e4
     }
   });
-  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: 1e4
     }
   });
-  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: 1e4
     }
   });
-  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