@morpho-dev/router 0.6.0 → 0.7.1

package/dist/index.node.mjs

@@ -12,10 +12,12 @@ import "@opentelemetry/propagator-aws-xray";
 import "@opentelemetry/resources";
 import "@opentelemetry/sdk-trace-node";
 import "@opentelemetry/semantic-conventions";
+import { and, asc, eq, gt, gte, inArray, lte, ne, sql } from "drizzle-orm";
 import { anvil, base, mainnet } from "viem/chains";
 import * as z$1 from "zod";
 import { StandardMerkleTree } from "@openzeppelin/merkle-tree";
 import { gzip, ungzip } from "pako";
+import { bigint, boolean, foreignKey, index, integer, numeric, pgSchema, primaryKey, serial, text, timestamp, uniqueIndex, varchar } from "drizzle-orm/pg-core";
 import { serve } from "@hono/node-server";
 import { Hono } from "hono";
 import { cors } from "hono/cors";
@@ -29,8 +31,6 @@ import { readFile } from "node:fs/promises";
 import { dirname, resolve } from "node:path";
 import { fileURLToPath } from "node:url";
 import { marked } from "marked";
-import { and, asc, eq, gt, gte, inArray, lte, ne, sql } from "drizzle-orm";
-import { bigint, boolean, foreignKey, index, integer, numeric, pgSchema, primaryKey, serial, text, timestamp, uniqueIndex, varchar } from "drizzle-orm/pg-core";
 import createOpenApiFetchClient from "openapi-fetch";
 import { PGlite } from "@electric-sql/pglite";
 import { drizzle } from "drizzle-orm/node-postgres";
@@ -1104,107 +1104,14 @@ const Morpho = [
 //#region src/core/Callback.ts
 var Callback_exports = /* @__PURE__ */ __exportAll({
 	Type: () => Type$1,
-	decode: () => decode$2,
-	decodeBuyERC20: () => decodeBuyERC20,
-	decodeBuyVaultV1Callback: () => decodeBuyVaultV1Callback,
-	decodeSellERC20Callback: () => decodeSellERC20Callback,
-	encode: () => encode$2,
-	encodeBuyERC20: () => encodeBuyERC20,
-	encodeBuyVaultV1Callback: () => encodeBuyVaultV1Callback,
-	encodeSellERC20Callback: () => encodeSellERC20Callback,
 	isEmptyCallback: () => isEmptyCallback
 });
 let Type$1 = /* @__PURE__ */ function(Type) {
 	Type["BuyWithEmptyCallback"] = "buy_with_empty_callback";
-	Type["BuyERC20"] = "buy_erc20";
-	Type["BuyVaultV1Callback"] = "buy_vault_v1_callback";
-	Type["SellERC20Callback"] = "sell_erc20_callback";
+	Type["SellWithEmptyCallback"] = "sell_with_empty_callback";
 	return Type;
 }({});
 const isEmptyCallback = (offer) => offer.callback.data === "0x";
-function decode$2(type, data) {
-	switch (type) {
-		case Type$1.BuyERC20: return decodeBuyERC20(data);
-		case Type$1.BuyVaultV1Callback: return decodeBuyVaultV1Callback(data);
-		case Type$1.SellERC20Callback: return decodeSellERC20Callback(data);
-		default: throw new Error("Invalid callback type");
-	}
-}
-function encode$2(type, data) {
-	switch (type) {
-		case Type$1.BuyERC20:
-			if (!("tokens" in data)) throw new Error("Invalid callback data");
-			return encodeBuyERC20(data);
-		case Type$1.BuyVaultV1Callback:
-			if (!("vaults" in data)) throw new Error("Invalid callback data");
-			return encodeBuyVaultV1Callback(data);
-		case Type$1.SellERC20Callback:
-			if (!("collaterals" in data)) throw new Error("Invalid callback data");
-			return encodeSellERC20Callback(data);
-		default: throw new Error("Invalid callback type");
-	}
-}
-/**
-* Decodes BuyERC20 callback data into positions.
-* @param data - The ABI-encoded callback data containing token addresses and amounts.
-* @returns Array of positions with contract address and amount.
-* @throws If data is empty, malformed, or arrays have mismatched lengths.
-*/
-function decodeBuyERC20(data) {
-	if (!data || data === "0x") throw new Error("Empty callback data");
-	let tokens;
-	let amounts;
-	try {
-		[tokens, amounts] = decodeAbiParameters([{ type: "address[]" }, { type: "uint256[]" }], data);
-	} catch (_) {
-		throw new Error("Invalid BuyERC20 callback data");
-	}
-	if (tokens.length !== amounts.length) throw new Error("Mismatched array lengths");
-	return tokens.map((token, index) => ({
-		contract: token,
-		amount: amounts[index]
-	}));
-}
-/**
-* Encodes BuyERC20 callback parameters into ABI-encoded data.
-* @param parameters - The tokens and amounts to encode.
-* @returns ABI-encoded hex string.
-*/
-function encodeBuyERC20(parameters) {
-	return encodeAbiParameters([{ type: "address[]" }, { type: "uint256[]" }], [parameters.tokens, parameters.amounts]);
-}
-function decodeBuyVaultV1Callback(data) {
-	if (!data || data === "0x") throw new Error("Empty callback data");
-	try {
-		const [vaults, amounts] = decodeAbiParameters([{ type: "address[]" }, { type: "uint256[]" }], data);
-		if (vaults.length !== amounts.length) throw new Error("Mismatched array lengths");
-		return vaults.map((v, i) => ({
-			contract: v,
-			amount: amounts[i]
-		}));
-	} catch (_) {
-		throw new Error("Invalid BuyVaultV1Callback callback data");
-	}
-}
-function decodeSellERC20Callback(data) {
-	if (!data || data === "0x") throw new Error("Empty callback data");
-	try {
-		const [collaterals, amounts] = decodeAbiParameters([{ type: "address[]" }, { type: "uint256[]" }], data);
-		if (collaterals.length !== amounts.length) throw new Error("Mismatched array lengths");
-		return collaterals.map((c, i) => ({
-			contract: c,
-			amount: amounts[i]
-		}));
-	} catch (_) {
-		throw new Error("Invalid SellERC20Callback callback data");
-	}
-}
-function encodeBuyVaultV1Callback(parameters) {
-	return encodeAbiParameters([{ type: "address[]" }, { type: "uint256[]" }], [parameters.vaults, parameters.amounts]);
-}
-function encodeSellERC20Callback(parameters) {
-	return encodeAbiParameters([{ type: "address[]" }, { type: "uint256[]" }], [parameters.collaterals, parameters.amounts]);
-}
 
 //#endregion
 //#region src/core/Chain.ts
@@ -1726,11 +1633,9 @@ var Liquidity_exports = /* @__PURE__ */ __exportAll({
 	calculateMaxDebt: () => calculateMaxDebt,
 	generateAllowancePoolId: () => generateAllowancePoolId,
 	generateBalancePoolId: () => generateBalancePoolId,
-	generateBuyVaultCallbackPoolId: () => generateBuyVaultCallbackPoolId,
 	generateDebtPoolId: () => generateDebtPoolId,
 	generateMarketLiquidityPoolId: () => generateMarketLiquidityPoolId,
 	generateObligationCollateralPoolId: () => generateObligationCollateralPoolId,
-	generateSellERC20CallbackPoolId: () => generateSellERC20CallbackPoolId,
 	generateUserVaultPositionPoolId: () => generateUserVaultPositionPoolId,
 	generateVaultPositionPoolId: () => generateVaultPositionPoolId
 });
@@ -1759,14 +1664,6 @@ function generateAllowancePoolId(parameters) {
 	return `${user}-${chainId.toString()}-${token}-allowance`.toLowerCase();
 }
 /**
-* Generate pool ID for sell ERC20 callback pools.
-* Each offer has its own callback pool to prevent liquidity conflicts.
-*/
-function generateSellERC20CallbackPoolId(parameters) {
-	const { user, chainId, obligationId, token, offerHash } = parameters;
-	return `${user}-${chainId.toString()}-${obligationId}-${token}-${offerHash}-sell_erc20_callback`.toLowerCase();
-}
-/**
 * Generate pool ID for obligation collateral pools.
 * Obligation collateral pools represent collateral already deposited in the obligation.
 * These pools are shared across all offers with the same obligation.
@@ -1776,13 +1673,6 @@ function generateObligationCollateralPoolId(parameters) {
 	return `${user}-${chainId.toString()}-${obligationId}-${token}-obligation-collateral`.toLowerCase();
 }
 /**
-* Generate pool ID for buy vault callback pools.
-*/
-function generateBuyVaultCallbackPoolId(parameters) {
-	const { user, chainId, vault, offerHash } = parameters;
-	return `${user}-${chainId.toString()}-${vault}-${offerHash}-${Type$1.BuyVaultV1Callback}`.toLowerCase();
-}
-/**
 * Generate pool ID for debt pools.
 */
 function generateDebtPoolId(parameters) {
@@ -2117,6 +2007,7 @@ var Offer_exports = /* @__PURE__ */ __exportAll({
 	obligationId: () => obligationId,
 	random: () => random$1,
 	serialize: () => serialize,
+	takeEvent: () => takeEvent,
 	toSnakeCase: () => toSnakeCase,
 	types: () => types
 });
@@ -2235,7 +2126,7 @@ function random$1(config) {
 	const chain = config?.chains ? config.chains[int(config.chains.length)] : chains$2.ethereum;
 	const loanToken = config?.loanTokens ? config.loanTokens[int(config.loanTokens.length)] : address();
 	const collateralCandidates = config?.collateralTokens ? config.collateralTokens.filter((a) => a !== loanToken) : [address()];
-	const collateralAsset = collateralCandidates[int(collateralCandidates.length)];
+	collateralCandidates[int(collateralCandidates.length)];
 	const maturityOption = weightedChoice([["end_of_month", 1], ["end_of_next_month", 1]]);
 	const maturity = config?.maturity ?? from$16(maturityOption);
 	const lltv = from$18(weightedChoice([
@@ -2262,21 +2153,10 @@ function random$1(config) {
 	const unit = BigInt(10) ** BigInt(loanTokenDecimals);
 	const amountBase = BigInt(100 + int(999901));
 	const assetsScaled = config?.assets ?? amountBase * unit;
-	const callbackBySide = (() => {
-		if (buy) return {
-			address: zeroAddress,
-			data: "0x"
-		};
-		const sellCallbackAddress = "0x3333333333333333333333333333333333333333";
-		const amount = assetsScaled * 1000000000000000000000n;
-		return {
-			address: sellCallbackAddress,
-			data: encodeSellERC20Callback({
-				collaterals: [collateralAsset],
-				amounts: [amount]
-			})
-		};
-	})();
+	const emptyCallback = {
+		address: zeroAddress,
+		data: "0x"
+	};
 	return from$14({
 		maker: config?.maker ?? address(),
 		assets: assetsScaled,
@@ -2295,7 +2175,7 @@ function random$1(config) {
 			...random$3(),
 			lltv
 		})).sort((a, b) => a.asset.localeCompare(b.asset)),
-		callback: config?.callback ?? callbackBySide
+		callback: config?.callback ?? emptyCallback
 	});
 }
 const weightedChoice = (pairs) => {
@@ -2585,6 +2465,94 @@ function decode$1(data) {
 	});
 }
 /**
+* ABI for the Take event emitted by the Morpho V2 contract.
+*/
+const takeEvent = {
+	type: "event",
+	name: "Take",
+	inputs: [
+		{
+			name: "caller",
+			type: "address",
+			indexed: false,
+			internalType: "address"
+		},
+		{
+			name: "id",
+			type: "bytes32",
+			indexed: true,
+			internalType: "bytes32"
+		},
+		{
+			name: "maker",
+			type: "address",
+			indexed: true,
+			internalType: "address"
+		},
+		{
+			name: "taker",
+			type: "address",
+			indexed: true,
+			internalType: "address"
+		},
+		{
+			name: "offerIsBuy",
+			type: "bool",
+			indexed: false,
+			internalType: "bool"
+		},
+		{
+			name: "buyerAssets",
+			type: "uint256",
+			indexed: false,
+			internalType: "uint256"
+		},
+		{
+			name: "sellerAssets",
+			type: "uint256",
+			indexed: false,
+			internalType: "uint256"
+		},
+		{
+			name: "obligationUnits",
+			type: "uint256",
+			indexed: false,
+			internalType: "uint256"
+		},
+		{
+			name: "obligationShares",
+			type: "uint256",
+			indexed: false,
+			internalType: "uint256"
+		},
+		{
+			name: "buyerIsLender",
+			type: "bool",
+			indexed: false,
+			internalType: "bool"
+		},
+		{
+			name: "sellerIsBorrower",
+			type: "bool",
+			indexed: false,
+			internalType: "bool"
+		},
+		{
+			name: "group",
+			type: "bytes32",
+			indexed: false,
+			internalType: "bytes32"
+		},
+		{
+			name: "consumed",
+			type: "uint256",
+			indexed: false,
+			internalType: "uint256"
+		}
+	],
+	anonymous: false
+};
+/**
 * ABI for the Consume event emitted by the Obligation contract.
 */
 const consumedEvent = {
@@ -3336,160 +3304,701 @@ var SignatureDomainError = class extends BaseError {
 const BrandTypeId = Symbol.for("mempool/Brand");
 
 //#endregion
-//#region src/indexer/collectors/CollectFunctions/collectConsumedEvents.ts
-async function* collectConsumedEvents(parameters) {
-	let { db, collector, client, lastBlockNumber: blockNumber, epoch, options: { maxBatchSize = 1e3, blockWindow } = {} } = parameters;
-	const logger = getLogger();
-	let startBlock = blockNumber;
-	let reorgDetected = false;
-	const { blockNumber: latestBlockNumberChain } = await db.blocks.getChain(client.chain.id);
-	const stream = streamLogs({
-		client,
-		contractAddress: client.chain.custom.morpho.address,
-		event: consumedEvent,
-		blockNumberGte: blockNumber,
-		blockNumberLte: latestBlockNumberChain,
-		order: "asc",
-		options: {
-			maxBatchSize,
-			blockWindow
-		}
-	});
-	for await (const { logs, blockNumber: lastStreamBlockNumber } of stream) {
-		const parsedLogs = parseEventLogs({
-			abi: [consumedEvent],
-			logs
-		});
-		const events = [];
-		for (const log of parsedLogs) {
-			if (log.blockNumber === null || log.logIndex === null || log.transactionHash === null) {
-				logger.debug({
-					collector,
-					chainId: client.chain.id,
-					msg: "Skipping log because it is missing required fields"
-				});
-				continue;
-			}
-			events.push({
-				id: `${log.blockNumber.toString()}-${log.logIndex.toString()}-${client.chain.id}-${log.transactionHash}`,
-				chainId: client.chain.id,
-				maker: log.args.user,
-				group: log.args.group,
-				amount: log.args.amount,
-				blockNumber: Number(log.blockNumber)
-			});
-		}
-		await db.transaction(async (dbTx) => {
-			try {
-				await dbTx.consumed.create(events);
-				if (events.length > 0) logger.info({
-					msg: `Events indexed`,
-					collector,
-					count: events.length,
-					chain_id: client.chain.id,
-					block_range: [startBlock, lastStreamBlockNumber]
-				});
-			} catch (err) {
-				logger.error({
-					err,
-					msg: "Failed to process offer_consumed events"
-				});
-			}
-			blockNumber = lastStreamBlockNumber;
-			try {
-				await dbTx.blocks.advanceCollector({
-					collectorName: collector,
-					chainId: client.chain.id,
-					blockNumber,
-					epoch
-				});
-			} catch (_) {
-				try {
-					const ancestor = await dbTx.blocks.getCollector({
-						collectorName: collector,
-						chainId: client.chain.id
-					});
-					blockNumber = ancestor.blockNumber;
-					const deleted = await dbTx.consumed.delete({
-						chainId: client.chain.id,
-						blockNumberGte: blockNumber + 1
-					});
-					logger.info({
-						collector,
-						chain_id: client.chain.id,
-						msg: `Reorg detected, events deleted`,
-						count: deleted,
-						block_number: blockNumber
-					});
-					await dbTx.blocks.advanceCollector({
-						collectorName: collector,
-						chainId: client.chain.id,
-						blockNumber,
-						epoch: ancestor.epoch
-					});
-					reorgDetected = true;
-				} catch (err) {
-					const msg = "Failed to delete consumed events when handling reorg.";
-					logger.error({
-						collector,
-						chainId: client.chain.id,
-						msg,
-						err
-					});
-					throw new Error(msg);
-				}
-			}
-		});
-		if (reorgDetected) return;
-		yield blockNumber;
-		startBlock = blockNumber;
-	}
-}
+//#region src/database/drizzle/VERSION.ts
+const VERSION = "router_v1.6";
 
 //#endregion
-//#region src/indexer/collectors/CollectFunctions/collectOffers.ts
-async function* collectOffersV2(parameters) {
-	let { db, collector, client, lastBlockNumber: blockNumber, gatekeeper, options: { maxBatchSize = 1e3, blockWindow } = {} } = parameters;
-	const logger = getLogger();
-	let startBlock = blockNumber;
-	let reorgDetected = false;
-	if (client.chain.custom.morpho.address.toLowerCase() === zeroAddress) {
-		const msg = "Morpho V2 address is zero, signature verification will fail. Please set the Morpho V2 address in the chain configuration.";
-		logger.error({
-			msg,
-			chain_id: client.chain.id
-		});
-		throw new Error(msg);
-	}
-	const signatureDomain = {
-		chainId: client.chain.id,
-		verifyingContract: client.chain.custom.morpho.address
-	};
-	const { blockNumber: latestBlockNumberChain } = await db.blocks.getChain(client.chain.id);
-	const stream = streamLogs({
-		client,
-		contractAddress: client.chain.custom.mempool.address,
-		event: {
-			type: "event",
-			name: "Event",
-			inputs: [{
-				name: "data",
-				type: "bytes",
-				indexed: false,
-				internalType: "bytes"
-			}],
-			anonymous: false
-		},
-		blockNumberGte: blockNumber,
-		blockNumberLte: latestBlockNumberChain,
-		order: "asc",
-		options: {
-			maxBatchSize,
-			blockWindow
-		}
-	});
-	for await (const { logs, blockNumber: lastStreamBlockNumber } of stream) {
-		blockNumber = lastStreamBlockNumber;
+//#region src/database/drizzle/schema.ts
+var schema_exports = /* @__PURE__ */ __exportAll({
+	PositionTypes: () => PositionTypes,
+	StatusCode: () => StatusCode,
+	TABLE_NAMES: () => TABLE_NAMES,
+	VERSIONED_TABLE_NAMES: () => VERSIONED_TABLE_NAMES,
+	callbacks: () => callbacks,
+	chains: () => chains$1,
+	collectors: () => collectors,
+	consumedEvents: () => consumedEvents,
+	groups: () => groups,
+	lots: () => lots,
+	merklePaths: () => merklePaths,
+	obligationCollateralsV2: () => obligationCollateralsV2,
+	obligations: () => obligations,
+	offers: () => offers,
+	offersCallbacks: () => offersCallbacks,
+	offsets: () => offsets,
+	oracles: () => oracles$1,
+	positionTypes: () => positionTypes,
+	positions: () => positions,
+	status: () => status,
+	transfers: () => transfers,
+	trees: () => trees,
+	validations: () => validations
+});
+const s = pgSchema(VERSION);
+var EnumTableName = /* @__PURE__ */ function(EnumTableName) {
+	EnumTableName["OBLIGATIONS"] = "obligations";
+	EnumTableName["GROUPS"] = "groups";
+	EnumTableName["CONSUMED_EVENTS"] = "consumed_events";
+	EnumTableName["OBLIGATION_COLLATERALS_V2"] = "obligation_collaterals_v2";
+	EnumTableName["ORACLES"] = "oracles";
+	EnumTableName["OFFERS"] = "offers";
+	EnumTableName["OFFERS_CALLBACKS"] = "offers_callbacks";
+	EnumTableName["CALLBACKS"] = "callbacks";
+	EnumTableName["POSITIONS"] = "positions";
+	EnumTableName["TRANSFERS"] = "transfers";
+	EnumTableName["VALIDATIONS"] = "validations";
+	EnumTableName["COLLECTORS"] = "collectors";
+	EnumTableName["CHAINS"] = "chains";
+	EnumTableName["LOTS"] = "lots";
+	EnumTableName["OFFSETS"] = "offsets";
+	EnumTableName["TREES"] = "trees";
+	EnumTableName["MERKLE_PATHS"] = "merkle_paths";
+	return EnumTableName;
+}(EnumTableName || {});
+const TABLE_NAMES = Object.values(EnumTableName);
+const VERSIONED_TABLE_NAMES = TABLE_NAMES.map((table) => `"${VERSION}"."${table}"`);
+const obligations = s.table(EnumTableName.OBLIGATIONS, {
+	obligationId: varchar("obligation_id", { length: 66 }).primaryKey(),
+	chainId: bigint("chain_id", { mode: "number" }).$type().notNull(),
+	loanToken: varchar("loan_token", { length: 42 }).notNull(),
+	maturity: integer("maturity").notNull()
+});
+const groups = s.table(EnumTableName.GROUPS, {
+	chainId: bigint("chain_id", { mode: "number" }).$type().notNull(),
+	maker: varchar("maker", { length: 42 }).notNull(),
+	group: varchar("group", { length: 66 }).notNull(),
+	consumed: numeric("consumed", {
+		precision: 78,
+		scale: 0
+	}).notNull(),
+	blockNumber: bigint("block_number", { mode: "number" }).notNull(),
+	updatedAt: timestamp("updated_at").defaultNow().notNull()
+}, (table) => [primaryKey({
+	columns: [
+		table.chainId,
+		table.maker,
+		table.group
+	],
+	name: "groups_pk"
+}), index("groups_chain_id_maker_group_consumed_idx").on(table.chainId, table.maker, table.group, table.consumed)]);
+const consumedEvents = s.table(EnumTableName.CONSUMED_EVENTS, {
+	eventId: varchar("event_id", { length: 128 }).primaryKey(),
+	chainId: bigint("chain_id", { mode: "number" }).$type().notNull(),
+	maker: varchar("maker", { length: 42 }).notNull(),
+	group: varchar("group", { length: 66 }).notNull(),
+	amount: numeric("amount", {
+		precision: 78,
+		scale: 0
+	}).notNull(),
+	blockNumber: bigint("block_number", { mode: "number" }).notNull(),
+	createdAt: timestamp("created_at").defaultNow().notNull()
+}, (t) => [
+	foreignKey({
+		columns: [
+			t.chainId,
+			t.maker,
+			t.group
+		],
+		foreignColumns: [
+			groups.chainId,
+			groups.maker,
+			groups.group
+		],
+		name: "consumed_events_groups_fk"
+	}).onDelete("cascade"),
+	index("consumed_events_group_idx").on(t.chainId, t.maker, t.group),
+	index("consumed_events_block_number_idx").on(t.blockNumber)
+]);
+const obligationCollateralsV2 = s.table(EnumTableName.OBLIGATION_COLLATERALS_V2, {
+	obligationId: varchar("obligation_id", { length: 66 }).notNull().references(() => obligations.obligationId, { onDelete: "cascade" }),
+	asset: varchar("asset", { length: 42 }).notNull(),
+	oracleChainId: bigint("oracle_chain_id", { mode: "number" }).$type().notNull(),
+	oracleAddress: varchar("oracle_address", { length: 42 }).notNull(),
+	lltv: bigint("lltv", { mode: "bigint" }).notNull(),
+	updatedAt: timestamp("updated_at").defaultNow().notNull()
+}, (table) => [
+	primaryKey({
+		columns: [table.obligationId, table.asset],
+		name: "obligation_collaterals_v2_pk"
+	}),
+	foreignKey({
+		columns: [table.oracleChainId, table.oracleAddress],
+		foreignColumns: [oracles$1.chainId, oracles$1.address],
+		name: "obligation_collaterals_v2_oracles_fk"
+	}),
+	index("obligation_collaterals_v2_obligation_id_idx").on(table.obligationId),
+	index("obligation_collaterals_v2_oracle_fk_idx").on(table.oracleChainId, table.oracleAddress)
+]);
+const oracles$1 = s.table(EnumTableName.ORACLES, {
+	chainId: bigint("chain_id", { mode: "number" }).$type().notNull(),
+	address: varchar("address", { length: 42 }).notNull(),
+	price: numeric("price", {
+		precision: 78,
+		scale: 0
+	}),
+	blockNumber: bigint("block_number", { mode: "number" }).notNull(),
+	updatedAt: timestamp("updated_at").defaultNow().notNull()
+}, (table) => [primaryKey({
+	columns: [table.chainId, table.address],
+	name: "oracles_pk"
+})]);
+const offers = s.table(EnumTableName.OFFERS, {
+	hash: varchar("hash", { length: 66 }).primaryKey(),
+	obligationId: varchar("obligation_id", { length: 66 }).notNull().references(() => obligations.obligationId, { onDelete: "cascade" }),
+	assets: numeric("assets", {
+		precision: 78,
+		scale: 0
+	}).notNull(),
+	obligationUnits: numeric("obligation_units", {
+		precision: 78,
+		scale: 0
+	}).notNull().default("0"),
+	obligationShares: numeric("obligation_shares", {
+		precision: 78,
+		scale: 0
+	}).notNull().default("0"),
+	price: numeric("price", {
+		precision: 78,
+		scale: 0
+	}).notNull(),
+	maturity: integer("maturity").notNull(),
+	expiry: integer("expiry").notNull(),
+	start: integer("start").notNull(),
+	groupChainId: bigint("group_chain_id", { mode: "number" }).$type().notNull(),
+	groupMaker: varchar("group_maker", { length: 42 }).notNull(),
+	group: varchar("group_group", { length: 66 }).notNull(),
+	session: varchar("session", { length: 66 }).notNull(),
+	buy: boolean("buy").notNull(),
+	callbackAddress: varchar("callback_address", { length: 42 }).notNull(),
+	callbackData: text("callback_data").notNull(),
+	blockNumber: bigint("block_number", { mode: "number" }).notNull(),
+	updatedAt: timestamp("updated_at").defaultNow().notNull()
+}, (table) => [
+	foreignKey({
+		columns: [
+			table.groupChainId,
+			table.groupMaker,
+			table.group
+		],
+		foreignColumns: [
+			groups.chainId,
+			groups.maker,
+			groups.group
+		],
+		name: "offers_groups_fk"
+	}).onDelete("cascade"),
+	index("offers_group_fk_idx").on(table.groupChainId, table.groupMaker, table.group),
+	index("offers_group_and_hash_idx").on(table.groupChainId, table.groupMaker, table.group, table.hash),
+	index("offers_obligation_id_side_idx").on(table.obligationId, table.buy)
+]);
+const offersCallbacks = s.table(EnumTableName.OFFERS_CALLBACKS, {
+	offerHash: varchar("offer_hash", { length: 66 }).notNull().references(() => offers.hash, { onDelete: "cascade" }),
+	callbackId: varchar("callback_id", { length: 66 })
+}, (table) => [primaryKey({
+	columns: [table.offerHash, table.callbackId],
+	name: "offers_callbacks_pk"
+})]);
+const callbacks = s.table(EnumTableName.CALLBACKS, {
+	id: varchar("id", { length: 66 }).primaryKey(),
+	positionChainId: bigint("position_chain_id", { mode: "number" }).$type().notNull(),
+	positionContract: varchar("position_contract", { length: 42 }).notNull(),
+	positionUser: varchar("position_user", { length: 42 }).notNull(),
+	amount: numeric("amount", {
+		precision: 78,
+		scale: 0
+	})
+}, (table) => [foreignKey({
+	columns: [
+		table.positionChainId,
+		table.positionContract,
+		table.positionUser
+	],
+	foreignColumns: [
+		positions.chainId,
+		positions.contract,
+		positions.user
+	],
+	name: "callbacks_positions_fk"
+}).onDelete("cascade")]);
+const lots = s.table(EnumTableName.LOTS, {
+	chainId: bigint("chain_id", { mode: "number" }).$type().notNull(),
+	user: varchar("user", { length: 42 }).notNull(),
+	contract: varchar("contract", { length: 42 }).notNull(),
+	group: varchar("group", { length: 66 }).notNull(),
+	lower: numeric("lower", {
+		precision: 78,
+		scale: 0
+	}).notNull(),
+	upper: numeric("upper", {
+		precision: 78,
+		scale: 0
+	}).notNull()
+}, (table) => [
+	primaryKey({
+		columns: [
+			table.chainId,
+			table.user,
+			table.contract,
+			table.group
+		],
+		name: "lots_pk"
+	}),
+	foreignKey({
+		columns: [
+			table.chainId,
+			table.contract,
+			table.user
+		],
+		foreignColumns: [
+			positions.chainId,
+			positions.contract,
+			positions.user
+		],
+		name: "lots_positions_fk"
+	}).onDelete("cascade"),
+	foreignKey({
+		columns: [
+			table.chainId,
+			table.user,
+			table.group
+		],
+		foreignColumns: [
+			groups.chainId,
+			groups.maker,
+			groups.group
+		],
+		name: "lots_groups_fk"
+	}).onDelete("cascade")
+]);
+const offsets = s.table(EnumTableName.OFFSETS, {
+	chainId: bigint("chain_id", { mode: "number" }).$type().notNull(),
+	user: varchar("user", { length: 42 }).notNull(),
+	contract: varchar("contract", { length: 42 }).notNull(),
+	group: varchar("group", { length: 66 }).notNull(),
+	value: numeric("value", {
+		precision: 78,
+		scale: 0
+	}).notNull()
+}, (table) => [primaryKey({
+	columns: [
+		table.chainId,
+		table.user,
+		table.contract,
+		table.group
+	],
+	name: "offsets_pk"
+}), foreignKey({
+	columns: [
+		table.chainId,
+		table.contract,
+		table.user
+	],
+	foreignColumns: [
+		positions.chainId,
+		positions.contract,
+		positions.user
+	],
+	name: "offsets_positions_fk"
+}).onDelete("cascade")]);
+const PositionTypes = s.enum("position_type", Object.values(Type));
+const positionTypes = s.table("position_types", {
+	id: serial("id").primaryKey(),
+	type: PositionTypes("type").notNull()
+});
+const positions = s.table(EnumTableName.POSITIONS, {
+	chainId: bigint("chain_id", { mode: "number" }).$type().notNull(),
+	contract: varchar("contract", { length: 42 }).notNull(),
+	user: varchar("user", { length: 42 }).notNull(),
+	positionTypeId: integer("position_type_id").notNull().references(() => positionTypes.id, { onDelete: "no action" }),
+	balance: numeric("balance", {
+		precision: 78,
+		scale: 0
+	}),
+	asset: varchar("asset", { length: 42 }),
+	blockNumber: bigint("block_number", { mode: "number" }).notNull(),
+	updatedAt: timestamp("updated_at").defaultNow().notNull()
+}, (table) => [primaryKey({
+	columns: [
+		table.chainId,
+		table.contract,
+		table.user
+	],
+	name: "positions_pk"
+})]);
+const transfers = s.table(EnumTableName.TRANSFERS, {
+	eventId: varchar("event_id", { length: 128 }).primaryKey(),
+	chainId: bigint("chain_id", { mode: "number" }).$type().notNull(),
+	contract: varchar("contract", { length: 42 }).notNull(),
+	from: varchar("from", { length: 42 }).notNull(),
+	to: varchar("to", { length: 42 }).notNull(),
+	value: numeric("value", {
+		precision: 78,
+		scale: 0
+	}).notNull(),
+	blockNumber: bigint("block_number", { mode: "number" }).notNull(),
+	createdAt: timestamp("created_at").defaultNow().notNull()
+}, (table) => [
+	foreignKey({
+		columns: [
+			table.chainId,
+			table.contract,
+			table.from
+		],
+		foreignColumns: [
+			positions.chainId,
+			positions.contract,
+			positions.user
+		],
+		name: "transfers_positions_from_fk"
+	}).onDelete("cascade"),
+	foreignKey({
+		columns: [
+			table.chainId,
+			table.contract,
+			table.to
+		],
+		foreignColumns: [
+			positions.chainId,
+			positions.contract,
+			positions.user
+		],
+		name: "transfers_positions_to_fk"
+	}).onDelete("cascade"),
+	index("transfers_chain_contract_user_idx").on(table.chainId, table.contract, table.from, table.to, table.blockNumber)
+]);
+const StatusCode = s.enum("status_code", Object.values(Status));
+const status = s.table("status", {
+	id: serial("id").primaryKey(),
+	code: StatusCode("code").unique()
+});
+const validations = s.table("validations", {
+	offerHash: varchar("offer_hash", { length: 66 }).primaryKey().references(() => offers.hash, { onDelete: "cascade" }),
+	statusId: integer("status_id").notNull().references(() => status.id, { onDelete: "no action" }),
+	updatedAt: timestamp("updated_at").defaultNow().notNull()
+});
+const collectors = s.table(EnumTableName.COLLECTORS, {
+	chainId: bigint("chain_id", { mode: "number" }).$type().notNull().references(() => chains$1.chainId, { onDelete: "no action" }),
+	name: text("name").$type().notNull(),
+	blockNumber: bigint("block_number", { mode: "number" }).notNull(),
+	epoch: numeric("epoch", {
+		precision: 78,
+		scale: 0
+	}).default("0").notNull(),
+	updatedAt: timestamp("updated_at").defaultNow().notNull()
+}, (table) => [uniqueIndex("collectors_chain_name_idx").on(table.chainId, table.name)]);
+const chains$1 = s.table(EnumTableName.CHAINS, {
+	chainId: bigint("chain_id", { mode: "number" }).$type().notNull(),
+	blockNumber: bigint("block_number", { mode: "number" }).notNull(),
+	epoch: numeric("epoch", {
+		precision: 78,
+		scale: 0
+	}).default("0").notNull(),
+	updatedAt: timestamp("updated_at").defaultNow().notNull()
+}, (table) => [uniqueIndex("chains_chain_id_idx").on(table.chainId)]);
+const trees = s.table(EnumTableName.TREES, {
+	root: varchar("root", { length: 66 }).primaryKey(),
+	rootSignature: varchar("root_signature", { length: 132 }).notNull(),
+	createdAt: timestamp("created_at").defaultNow().notNull()
+});
+const merklePaths = s.table(EnumTableName.MERKLE_PATHS, {
+	offerHash: varchar("offer_hash", { length: 66 }).primaryKey().references(() => offers.hash, { onDelete: "cascade" }),
+	treeRoot: varchar("tree_root", { length: 66 }).notNull().references(() => trees.root, { onDelete: "cascade" }),
+	proofNodes: text("proof_nodes").notNull(),
+	createdAt: timestamp("created_at").defaultNow().notNull()
+}, (table) => [index("merkle_paths_tree_root_idx").on(table.treeRoot)]);
+
+//#endregion
+//#region src/indexer/collectors/CollectFunctions/collectConsumedEvents.ts
+const buildGroupKey = (parameters) => {
+	return `${parameters.chainId}-${parameters.maker.toLowerCase()}-${parameters.group.toLowerCase()}`;
+};
+async function* collectConsumedEvents(parameters) {
+	let { db, collector, client, lastBlockNumber: blockNumber, epoch, options: { maxBatchSize = 1e3, blockWindow } = {} } = parameters;
+	const logger = getLogger();
+	let startBlock = blockNumber;
+	let reorgDetected = false;
+	const { blockNumber: latestBlockNumberChain } = await db.blocks.getChain(client.chain.id);
+	const stream = streamLogs({
+		client,
+		contractAddress: client.chain.custom.morpho.address,
+		blockNumberGte: blockNumber,
+		blockNumberLte: latestBlockNumberChain,
+		order: "asc",
+		options: {
+			maxBatchSize,
+			blockWindow
+		}
+	});
+	for await (const { logs, blockNumber: lastStreamBlockNumber } of stream) {
+		const parsedLogs = parseEventLogs({
+			abi: [consumedEvent, takeEvent],
+			logs,
+			strict: false
+		});
+		const normalizedLogs = [];
+		const groups$3 = /* @__PURE__ */ new Map();
+		const eventIds = /* @__PURE__ */ new Set();
+		const recordLog = (log) => {
+			normalizedLogs.push(log);
+			eventIds.add(log.id);
+			const groupKey = buildGroupKey({
+				chainId: log.chainId,
+				maker: log.maker,
+				group: log.group
+			});
+			if (!groups$3.has(groupKey)) groups$3.set(groupKey, {
+				chainId: log.chainId,
+				maker: log.maker.toLowerCase(),
+				group: log.group.toLowerCase()
+			});
+		};
+		for (const rawLog of parsedLogs) {
+			if (rawLog.blockNumber === null || rawLog.logIndex === null || rawLog.transactionHash === null) {
+				logger.debug({
+					collector,
+					chainId: client.chain.id,
+					msg: "Skipping log because it is missing required fields"
+				});
+				continue;
+			}
+			if (rawLog.eventName === consumedEvent.name) {
+				const consumeArgs = rawLog.args;
+				if (consumeArgs.user === void 0 || consumeArgs.group === void 0 || consumeArgs.amount === void 0) {
+					logger.debug({
+						collector,
+						chainId: client.chain.id,
+						msg: "Skipping Consume log because it is missing required args"
+					});
+					continue;
+				}
+				recordLog({
+					kind: "consume",
+					id: `${rawLog.blockNumber.toString()}-${rawLog.logIndex.toString()}-${client.chain.id}-${rawLog.transactionHash}`,
+					chainId: client.chain.id,
+					maker: consumeArgs.user,
+					group: consumeArgs.group,
+					amount: consumeArgs.amount,
+					blockNumber: Number(rawLog.blockNumber)
+				});
+				continue;
+			}
+			if (rawLog.eventName === takeEvent.name) {
+				const takeArgs = rawLog.args;
+				if (takeArgs.maker === void 0 || takeArgs.group === void 0 || takeArgs.consumed === void 0) {
+					logger.debug({
+						collector,
+						chainId: client.chain.id,
+						msg: "Skipping Take log because it is missing required args"
+					});
+					continue;
+				}
+				recordLog({
+					kind: "take",
+					id: `${rawLog.blockNumber.toString()}-${rawLog.logIndex.toString()}-${client.chain.id}-${rawLog.transactionHash}`,
+					chainId: client.chain.id,
+					maker: takeArgs.maker,
+					group: takeArgs.group,
+					consumed: takeArgs.consumed,
+					blockNumber: Number(rawLog.blockNumber)
+				});
+			}
+		}
+		await db.transaction(async (dbTx) => {
+			const existingEventIds = /* @__PURE__ */ new Set();
+			if (eventIds.size > 0) {
+				const ids = Array.from(eventIds);
+				for (let index = 0; index < ids.length; index += 500) {
+					const slice = ids.slice(index, index + 500);
+					const { rows } = await dbTx.execute(sql`
+            SELECT event_id
+            FROM ${consumedEvents}
+            WHERE event_id IN (${sql.join(slice.map((id) => sql`${id}`), sql`,`)});
+          `);
+					for (const row of rows) existingEventIds.add(row.event_id);
+				}
+			}
+			const consumedByGroup = /* @__PURE__ */ new Map();
+			if (groups$3.size > 0) {
+				const groupList = Array.from(groups$3.values());
+				for (let index = 0; index < groupList.length; index += 500) {
+					const slice = groupList.slice(index, index + 500);
+					const { rows } = await dbTx.execute(sql`
+            WITH targets(chain_id, maker, "group") AS (
+              VALUES ${sql.join(slice.map((group) => sql`(${group.chainId}::bigint, ${group.maker.toLowerCase()}::varchar(42), ${group.group.toLowerCase()}::varchar(66))`), sql`,`)}
+            )
+            SELECT
+              targets.chain_id,
+              targets.maker,
+              targets."group",
+              COALESCE(g.consumed, 0)::numeric AS consumed
+            FROM targets
+            LEFT JOIN ${groups} g
+              ON g.chain_id = targets.chain_id
+             AND g.maker = targets.maker
+             AND g."group" = targets."group";
+          `);
+					for (const row of rows) {
+						const groupKey = buildGroupKey({
+							chainId: Number(row.chain_id),
+							maker: row.maker,
+							group: row.group
+						});
+						consumedByGroup.set(groupKey, BigInt(row.consumed ?? "0"));
+					}
+				}
+			}
+			const events = [];
+			for (const log of normalizedLogs) {
+				if (existingEventIds.has(log.id)) continue;
+				const groupKey = buildGroupKey({
+					chainId: log.chainId,
+					maker: log.maker,
+					group: log.group
+				});
+				const previousConsumed = consumedByGroup.get(groupKey) ?? 0n;
+				if (log.kind === "consume") {
+					events.push({
+						id: log.id,
+						chainId: log.chainId,
+						maker: log.maker,
+						group: log.group,
+						amount: log.amount,
+						blockNumber: log.blockNumber
+					});
+					consumedByGroup.set(groupKey, previousConsumed + log.amount);
+					continue;
+				}
+				const delta = log.consumed - previousConsumed;
+				if (delta <= 0n) {
+					logger.debug({
+						collector,
+						chainId: client.chain.id,
+						msg: "Skipping Take log because consumed did not increase",
+						previous_consumed: previousConsumed.toString(),
+						consumed: log.consumed.toString()
+					});
+					continue;
+				}
+				events.push({
+					id: log.id,
+					chainId: log.chainId,
+					maker: log.maker,
+					group: log.group,
+					amount: delta,
+					blockNumber: log.blockNumber
+				});
+				consumedByGroup.set(groupKey, log.consumed);
+			}
+			try {
+				await dbTx.consumed.create(events);
+				if (events.length > 0) logger.info({
+					msg: `Events indexed`,
+					collector,
+					count: events.length,
+					chain_id: client.chain.id,
+					block_range: [startBlock, lastStreamBlockNumber]
+				});
+			} catch (err) {
+				logger.error({
+					err,
+					msg: "Failed to process consumed events"
+				});
+			}
+			blockNumber = lastStreamBlockNumber;
+			try {
+				await dbTx.blocks.advanceCollector({
+					collectorName: collector,
+					chainId: client.chain.id,
+					blockNumber,
+					epoch
+				});
+			} catch (_) {
+				try {
+					const ancestor = await dbTx.blocks.getCollector({
+						collectorName: collector,
+						chainId: client.chain.id
+					});
+					blockNumber = ancestor.blockNumber;
+					const deleted = await dbTx.consumed.delete({
+						chainId: client.chain.id,
+						blockNumberGte: blockNumber + 1
+					});
+					logger.info({
+						collector,
+						chain_id: client.chain.id,
+						msg: `Reorg detected, events deleted`,
+						count: deleted,
+						block_number: blockNumber
+					});
+					await dbTx.blocks.advanceCollector({
+						collectorName: collector,
+						chainId: client.chain.id,
+						blockNumber,
+						epoch: ancestor.epoch
+					});
+					reorgDetected = true;
+				} catch (err) {
+					const msg = "Failed to delete consumed events when handling reorg.";
+					logger.error({
+						collector,
+						chainId: client.chain.id,
+						msg,
+						err
+					});
+					throw new Error(msg, { cause: err });
+				}
+			}
+		});
+		if (reorgDetected) return;
+		yield blockNumber;
+		startBlock = blockNumber;
+	}
+}
+
+//#endregion
+//#region src/indexer/collectors/CollectFunctions/collectOffers.ts
+async function* collectOffersV2(parameters) {
+	let { db, collector, client, lastBlockNumber: blockNumber, gatekeeper, options: { maxBatchSize = 1e3, blockWindow } = {} } = parameters;
+	const logger = getLogger();
+	let startBlock = blockNumber;
+	let reorgDetected = false;
+	if (client.chain.custom.morpho.address.toLowerCase() === zeroAddress) {
+		const msg = "Morpho V2 address is zero, signature verification will fail. Please set the Morpho V2 address in the chain configuration.";
+		logger.error({
+			msg,
+			chain_id: client.chain.id
+		});
+		throw new Error(msg);
+	}
+	const signatureDomain = {
+		chainId: client.chain.id,
+		verifyingContract: client.chain.custom.morpho.address
+	};
+	const { blockNumber: latestBlockNumberChain } = await db.blocks.getChain(client.chain.id);
+	const stream = streamLogs({
+		client,
+		contractAddress: client.chain.custom.mempool.address,
+		event: {
+			type: "event",
+			name: "Event",
+			inputs: [{
+				name: "data",
+				type: "bytes",
+				indexed: false,
+				internalType: "bytes"
+			}],
+			anonymous: false
+		},
+		blockNumberGte: blockNumber,
+		blockNumberLte: latestBlockNumberChain,
+		order: "asc",
+		options: {
+			maxBatchSize,
+			blockWindow
+		}
+	});
+	for await (const { logs, blockNumber: lastStreamBlockNumber } of stream) {
+		blockNumber = lastStreamBlockNumber;
 		const decodedTrees = [];
 		for (const log of logs) {
 			if (!log) continue;
@@ -3575,9 +4084,8 @@ async function* collectOffersV2(parameters) {
 				offers: offersWithBlock,
 				hashes: insertedHashes
 			});
-			const { callbacks, positions, lots } = await decodeCallbacks({
+			const { callbacks, positions, lots } = decodeCallbacks({
 				chainId: client.chain.id,
-				gatekeeper,
 				offers: insertedOffers
 			});
 			if (positions.length > 0) await dbTx.positions.upsert(positions);
@@ -3640,83 +4148,44 @@ async function* collectOffersV2(parameters) {
 		startBlock = blockNumber;
 	}
 }
-async function decodeCallbacks(parameters) {
-	const { chainId, gatekeeper, offers } = parameters;
+function decodeCallbacks(parameters) {
+	const { offers } = parameters;
 	if (offers.length === 0) return {
 		callbacks: [],
 		positions: [],
 		lots: []
 	};
-	const addresses = offers.filter((entry) => entry.offer.callback.data !== "0x").map((entry) => entry.offer.callback.address);
-	if (addresses.length === 0) return {
-		callbacks: [],
-		positions: [],
-		lots: []
-	};
-	let response;
-	try {
-		response = await gatekeeper.getCallbackTypes({ callbacks: [{
-			chain_id: chainId,
-			addresses
-		}] });
-	} catch (err) {
-		const error = err instanceof Error ? err : new Error(String(err));
-		throw new Error("Failed to resolve callback types", { cause: error });
-	}
-	const entry = response.find((item) => item.chain_id === chainId);
-	const typeByAddress = /* @__PURE__ */ new Map();
-	if (entry) for (const [key, list] of Object.entries(entry)) {
-		if (key === "chain_id" || key === "not_supported") continue;
-		if (!Array.isArray(list)) continue;
-		for (const address of list) typeByAddress.set(address.toLowerCase(), key);
-	}
 	const callbacks = [];
 	const positions = [];
 	const lots = [];
 	for (const { offer, blockNumber: offerBlockNumber } of offers) {
-		if (offer.callback.data === "0x") continue;
-		const callbackType = typeByAddress.get(offer.callback.address.toLowerCase());
-		if (!callbackType) continue;
-		let decoded;
-		try {
-			decoded = decode$2(callbackType, offer.callback.data);
-		} catch (err) {
-			const error = err instanceof Error ? err : new Error(String(err));
-			throw new Error("Failed to decode callback data", { cause: error });
-		}
-		if (decoded.length === 0) continue;
-		const offerHash = hash(offer);
-		const callbackInputs = decoded.map((callback) => ({
+		if (!offer.buy) continue;
+		if (!isEmptyCallback(offer)) continue;
+		const loanToken = offer.loanToken.toLowerCase();
+		positions.push(from$12({
 			chainId: offer.chainId,
-			contract: callback.contract,
+			contract: loanToken,
 			user: offer.maker,
-			amount: callback.amount
+			type: Type.ERC20,
+			asset: loanToken,
+			blockNumber: offerBlockNumber
 		}));
-		callbacks.push({
-			offerHash,
-			callbacks: callbackInputs
+		lots.push({
+			positionChainId: offer.chainId,
+			positionContract: loanToken,
+			positionUser: offer.maker,
+			group: offer.group,
+			size: offer.assets
 		});
-		for (const callback of decoded) {
-			const contract = callback.contract;
-			const positionType = callbackType === Type$1.BuyVaultV1Callback ? Type.VAULT_V1 : Type.ERC20;
-			const asset = callbackType === Type$1.BuyVaultV1Callback ? void 0 : contract;
-			positions.push(from$12({
+		callbacks.push({
+			offerHash: hash(offer),
+			callbacks: [{
 				chainId: offer.chainId,
-				contract,
+				contract: loanToken,
 				user: offer.maker,
-				type: positionType,
-				asset,
-				blockNumber: offerBlockNumber
-			}));
-			const isLoanPosition = offer.loanToken.toLowerCase() === asset?.toLowerCase();
-			lots.push({
-				positionChainId: offer.chainId,
-				positionContract: contract,
-				positionUser: offer.maker,
-				group: offer.group,
-				size: isLoanPosition ? offer.assets : callback.amount
-			});
-		}
+				amount: offer.assets
+			}]
+		});
 	}
 	return {
 		callbacks,
@@ -4903,8 +5372,8 @@ const offerExample = {
 		price: "2750000000000000000",
 		group: "0x000000000000000000000000000000000000000000000000000000000008b8f4",
 		session: "0x0000000000000000000000000000000000000000000000000000000000000000",
-		callback: "0x1111111111111111111111111111111111111111",
-		callback_data: "0x00000000000000000000000000000000000000000000000000000000000000400000000000000000000000000000000000000000000000000000000000000080000000000000000000000000000000000000000000000000000000000000000100000000000000000000000034cf890db685fc536e05652fb41f02090c3fb751000000000000000000000000000000000000000000000000000000000000000100000000000000000000000000108e644e3ab01184155270aa92a00000000000"
+		callback: "0x0000000000000000000000000000000000000000",
+		callback_data: "0x"
 	},
 	offer_hash: "0xac4bd8318ec914f89f8af913f162230575b0ac0696a19256bc12138c5cfe1427",
 	obligation_id: "0x25690ae1aee324a005be565f3bcdd16dbf8daf7969b26c181c8b8f467dad9abc",
@@ -4956,25 +5425,10 @@ const validateOfferExample = {
 		lltv: "860000000000000000"
 	}],
 	callback: {
-		address: "0x1111111111111111111111111111111111111111",
-		data: "0x00000000000000000000000000000000000000000000000000000000000000400000000000000000000000000000000000000000000000000000000000000080000000000000000000000000000000000000000000000000000000000000000100000000000000000000000034cf890db685fc536e05652fb41f02090c3fb751000000000000000000000000000000000000000000000000000000000000000100000000000000000000000000108e644e3ab01184155270aa92a00000000000"
+		address: "0x0000000000000000000000000000000000000000",
+		data: "0x"
 	}
 };
-const callbackTypesRequestExample = { callbacks: [{
-	chain_id: 1,
-	addresses: [
-		"0x1111111111111111111111111111111111111111",
-		"0x3333333333333333333333333333333333333333",
-		"0x9999999999999999999999999999999999999999"
-	]
-}] };
-const callbackTypesResponseExample = [{
-	chain_id: 1,
-	sell_erc20_callback: ["0x1111111111111111111111111111111111111111"],
-	buy_erc20: ["0x5555555555555555555555555555555555555555"],
-	buy_vault_v1_callback: ["0x3333333333333333333333333333333333333333"],
-	not_supported: ["0x9999999999999999999999999999999999999999"]
-}];
 const routerStatusExample = {
 	status: "live",
 	initialized: true,
@@ -5043,55 +5497,6 @@ __decorate([ApiProperty({
 	type: "string",
 	example: validateOfferExample.callback.data
 })], ValidateCallbackRequest.prototype, "data", void 0);
-var CallbackTypesChainRequest = class {};
-__decorate([ApiProperty({
-	type: "number",
-	example: callbackTypesRequestExample.callbacks[0].chain_id
-})], CallbackTypesChainRequest.prototype, "chain_id", void 0);
-__decorate([ApiProperty({
-	type: () => [String],
-	example: callbackTypesRequestExample.callbacks[0].addresses
-})], CallbackTypesChainRequest.prototype, "addresses", void 0);
-var CallbackTypesRequest = class {};
-__decorate([ApiProperty({
-	type: () => [CallbackTypesChainRequest],
-	example: callbackTypesRequestExample.callbacks
-})], CallbackTypesRequest.prototype, "callbacks", void 0);
-var CallbackTypesChainResponse = class {};
-__decorate([ApiProperty({
-	type: "number",
-	example: callbackTypesResponseExample[0].chain_id
-})], CallbackTypesChainResponse.prototype, "chain_id", void 0);
-__decorate([ApiProperty({
-	type: () => [String],
-	required: false,
-	example: callbackTypesResponseExample[0].buy_vault_v1_callback
-})], CallbackTypesChainResponse.prototype, "buy_vault_v1_callback", void 0);
-__decorate([ApiProperty({
-	type: () => [String],
-	required: false,
-	example: callbackTypesResponseExample[0].sell_erc20_callback
-})], CallbackTypesChainResponse.prototype, "sell_erc20_callback", void 0);
-__decorate([ApiProperty({
-	type: () => [String],
-	required: false,
-	example: callbackTypesResponseExample[0].buy_erc20
-})], CallbackTypesChainResponse.prototype, "buy_erc20", void 0);
-__decorate([ApiProperty({
-	type: () => [String],
-	example: callbackTypesResponseExample[0].not_supported
-})], CallbackTypesChainResponse.prototype, "not_supported", void 0);
-var CallbackTypesSuccessResponse = class extends SuccessResponse {};
-__decorate([ApiProperty({
-	type: "string",
-	nullable: true,
-	example: "maturity:1:1730415600:end_of_next_month"
-})], CallbackTypesSuccessResponse.prototype, "cursor", void 0);
-__decorate([ApiProperty({
-	type: () => [CallbackTypesChainResponse],
-	description: "Callback types grouped by chain.",
-	example: callbackTypesResponseExample
-})], CallbackTypesSuccessResponse.prototype, "data", void 0);
 var AskResponse = class {};
 __decorate([ApiProperty({
 	type: "string",
@@ -5256,7 +5661,8 @@ var OfferListResponse = class extends SuccessResponse {};
 __decorate([ApiProperty({
 	type: "string",
 	nullable: true,
-	example: offerCursorExample
+	example: offerCursorExample,
+	description: "Pagination cursor. Offer hash (0x...) for maker queries; base64url-encoded cursor for obligation queries."
 })], OfferListResponse.prototype, "cursor", void 0);
 __decorate([ApiProperty({
 	type: () => [OfferListItemResponse],
@@ -5608,7 +6014,7 @@ __decorate([
 		methods: ["post"],
 		path: "/v1/validate",
 		summary: "Validate offers",
-		description: "Validates offers against router validation rules. Returns unsigned payload + root on success, or issues only on validation failure."
+		description: "Validates offers against router validation rules. Only empty callbacks (zero address, 0x data) are accepted. Returns unsigned payload + root on success, or issues only on validation failure."
 	}),
 	ApiBody({ type: ValidateOffersRequest }),
 	ApiResponse({
@@ -5627,28 +6033,6 @@ ValidateController = __decorate([ApiTags("Make"), ApiResponse({
 	description: "Bad Request",
 	type: BadRequestResponse
 })], ValidateController);
-let CallbacksController = class CallbacksController {
-	async resolveCallbackTypes() {}
-};
-__decorate([
-	ApiOperation({
-		methods: ["post"],
-		path: "/v1/callbacks",
-		summary: "Resolve callback types",
-		description: "Returns callback types for callback addresses grouped by chain."
-	}),
-	ApiBody({ type: CallbackTypesRequest }),
-	ApiResponse({
-		status: 200,
-		description: "Success",
-		type: CallbackTypesSuccessResponse
-	})
-], CallbacksController.prototype, "resolveCallbackTypes", null);
-CallbacksController = __decorate([ApiTags("Make"), ApiResponse({
-	status: 400,
-	description: "Bad Request",
-	type: BadRequestResponse
-})], CallbacksController);
 let OffersController = class OffersController {
 	async getOffers() {}
 };
@@ -5798,22 +6182,21 @@ const configRulesMaturityExample = {
 	name: "end_of_next_month",
 	timestamp: 1730415600
 };
-const configRulesCallbackExample = {
-	type: "callback",
-	chain_id: 1,
-	address: "0x1111111111111111111111111111111111111111",
-	callback_type: "sell_erc20_callback"
-};
 const configRulesLoanTokenExample = {
 	type: "loan_token",
 	chain_id: 1,
 	address: "0xA0b86991c6218b36c1d19D4a2e9Eb0cE3606eB48"
 };
+const configRulesOracleExample = {
+	type: "oracle",
+	chain_id: 1,
+	address: "0xDddd770BADd886dF3864029e4B377B5F6a2B6b83"
+};
 const configRulesChecksumExample = "f1d2d2f924e986ac86fdf7b36c94bcdf";
 const configRulesPayloadExample = [
 	configRulesMaturityExample,
-	configRulesCallbackExample,
-	configRulesLoanTokenExample
+	configRulesLoanTokenExample,
+	configRulesOracleExample
 ];
 const configContractNames = [
 	"mempool",
@@ -5876,14 +6259,9 @@ __decorate([ApiProperty({
 })], ConfigRulesRuleResponse.prototype, "timestamp", void 0);
 __decorate([ApiProperty({
 	type: "string",
-	example: configRulesCallbackExample.address,
+	example: configRulesLoanTokenExample.address,
 	required: false
 })], ConfigRulesRuleResponse.prototype, "address", void 0);
-__decorate([ApiProperty({
-	type: "string",
-	example: configRulesCallbackExample.callback_type,
-	required: false
-})], ConfigRulesRuleResponse.prototype, "callback_type", void 0);
 var ConfigRulesSuccessResponse = class {};
 __decorate([ApiProperty({ type: () => ConfigRulesMeta })], ConfigRulesSuccessResponse.prototype, "meta", void 0);
 __decorate([ApiProperty({
@@ -5944,7 +6322,7 @@ __decorate([
 		methods: ["get"],
 		path: "/v1/config/rules",
 		summary: "Get config rules",
-		description: "Returns configured rules for supported chains."
+		description: "Returns configured rules (maturities, loan tokens, oracles) for supported chains."
 	}),
 	ApiQuery({
 		name: "cursor",
@@ -5964,7 +6342,7 @@ __decorate([
 		name: "types",
 		type: ["string"],
 		required: false,
-		example: "maturity,loan_token",
+		example: "maturity,loan_token,oracle",
 		description: "Filter by rule types (comma-separated).",
 		style: "form",
 		explode: false
@@ -5979,1062 +6357,456 @@ __decorate([
 		explode: false
 	}),
 	ApiResponse({
-		status: 200,
-		description: "Success",
-		type: ConfigRulesSuccessResponse
-	})
-], ConfigRulesController.prototype, "getConfigRules", null);
-ConfigRulesController = __decorate([ApiTags("System")], ConfigRulesController);
-let ObligationsController = class ObligationsController {
-	async getObligations() {}
-	async getObligation() {}
-};
-__decorate([
-	ApiOperation({
-		methods: ["get"],
-		path: "/v1/obligations",
-		summary: "List all obligations",
-		description: "Returns a list of obligations with their current best ask and bid. Obligations are sorted by their id in ascending order by default."
-	}),
-	ApiQuery({
-		name: "cursor",
-		type: "string",
-		example: obligationCursorExample,
-		description: "Obligation id cursor for pagination."
-	}),
-	ApiQuery({
-		name: "limit",
-		type: "number",
-		example: 10,
-		description: "Maximum number of obligations to return."
-	}),
-	ApiQuery({
-		name: "chains",
-		type: ["number"],
-		required: false,
-		example: "1,8453",
-		description: "Filter by chain IDs (comma-separated).",
-		style: "form",
-		explode: false
-	}),
-	ApiQuery({
-		name: "loan_tokens",
-		type: ["string"],
-		required: false,
-		example: "0xC9A9C45C0eB717f8b5F193Af6bAa05A1c0Ac5078,0x34Cf890dB685FC536E05652FB41f02090c3fb751",
-		description: "Filter by loan token addresses (comma-separated).",
-		style: "form",
-		explode: false
-	}),
-	ApiQuery({
-		name: "collateral_tokens",
-		type: ["string"],
-		required: false,
-		example: "0x34Cf890dB685FC536E05652FB41f02090c3fb751,0xC9A9C45C0eB717f8b5F193Af6bAa05A1c0Ac5078",
-		description: "Filter by collateral tokens (comma-separated, matches any collateral).",
-		style: "form",
-		explode: false
-	}),
-	ApiQuery({
-		name: "maturities",
-		type: ["number"],
-		required: false,
-		example: "1761922800,1764524800",
-		description: "Filter by exact maturity timestamps (comma-separated, unix seconds).",
-		style: "form",
-		explode: false
-	}),
-	ApiResponse({
-		status: 200,
-		description: "Success",
-		type: ObligationListResponse
-	})
-], ObligationsController.prototype, "getObligations", null);
-__decorate([
-	ApiOperation({
-		methods: ["get"],
-		path: "/v1/obligations/{obligationId}",
-		summary: "Get an obligation",
-		description: "Returns an obligation by its id."
-	}),
-	ApiParam({
-		name: "obligationId",
-		type: "string",
-		example: "0x12590ae1aee324a005be565f3bcdd16dbf8daf7969b26c181c8b8f467dad9f67",
-		description: "Obligation id."
-	}),
-	ApiResponse({
-		status: 200,
-		description: "Success",
-		type: ObligationSingleSuccessResponse
-	})
-], ObligationsController.prototype, "getObligation", null);
-ObligationsController = __decorate([ApiTags("Markets"), ApiResponse({
-	status: 400,
-	description: "Bad Request",
-	type: BadRequestResponse
-})], ObligationsController);
-let UsersController = class UsersController {
-	async getUserPositions() {}
+		status: 200,
+		description: "Success",
+		type: ConfigRulesSuccessResponse
+	})
+], ConfigRulesController.prototype, "getConfigRules", null);
+ConfigRulesController = __decorate([ApiTags("System")], ConfigRulesController);
+let ObligationsController = class ObligationsController {
+	async getObligations() {}
+	async getObligation() {}
 };
 __decorate([
 	ApiOperation({
 		methods: ["get"],
-		path: "/v1/users/{userAddress}/positions",
-		summary: "Get user positions",
-		description: "Returns positions for a user with reserved balance. The reserved balance is the amount locked by active offers (max lot upper - offset - consumed)."
-	}),
-	ApiParam({
-		name: "userAddress",
-		type: "string",
-		example: "0x7b093658BE7f90B63D7c359e8f408e503c2D9401",
-		description: "User address to get positions for."
+		path: "/v1/obligations",
+		summary: "List all obligations",
+		description: "Returns a list of obligations with their current best ask and bid. Obligations are sorted by their id in ascending order by default."
 	}),
 	ApiQuery({
 		name: "cursor",
 		type: "string",
-		example: offerCursorExample,
-		description: "Pagination cursor in base64url-encoded format."
+		example: obligationCursorExample,
+		description: "Obligation id cursor for pagination."
 	}),
 	ApiQuery({
 		name: "limit",
 		type: "number",
 		example: 10,
-		description: "Maximum number of positions to return."
-	}),
-	ApiResponse({
-		status: 200,
-		description: "Success",
-		type: PositionListResponse
-	})
-], UsersController.prototype, "getUserPositions", null);
-UsersController = __decorate([ApiTags("Make"), ApiResponse({
-	status: 400,
-	description: "Bad Request",
-	type: BadRequestResponse
-})], UsersController);
-const OpenApi = async () => {
-	return await generateDocument({
-		controllers: [
-			BooksController,
-			ConfigContractsController,
-			ConfigRulesController,
-			OffersController,
-			ObligationsController,
-			HealthController,
-			UsersController,
-			ValidateController,
-			CallbacksController
-		],
-		document: {
-			openapi: "3.1.0",
-			info: {
-				title: "Router API",
-				version: "1.0.0",
-				description: "API for the Morpho Router"
-			},
-			servers: [{
-				url: "https://router.morpho.dev",
-				description: "Production server"
-			}, {
-				url: "http://localhost:7891",
-				description: "Local development server"
-			}],
-			tags: [
-				{
-					name: "Markets",
-					description: "Read-only endpoints to discover markets, order books and fetch current offers."
-				},
-				{
-					name: "Make",
-					description: "Utilities to ease making offers."
-				},
-				{
-					name: "System",
-					description: "Router configuration and health monitoring."
-				}
-			]
-		}
-	});
-};
-
-//#endregion
-//#region src/api/Schema/PositionResponse.ts
-var PositionResponse_exports = /* @__PURE__ */ __exportAll({ from: () => from$2 });
-/**
-* Creates a `PositionResponse` from a `PositionWithReserved`.
-* @param position - {@link PositionWithReserved}
-* @returns The created `PositionResponse`. {@link PositionResponse}
-*/
-function from$2(position) {
-	return {
-		chain_id: position.chainId,
-		contract: position.contract,
-		user: position.user,
-		reserved: position.reserved.toString(),
-		block_number: position.blockNumber
-	};
-}
-
-//#endregion
-//#region src/api/Schema/requests.ts
-const MAX_LIMIT = 100;
-const DEFAULT_LIMIT$4 = 20;
-const CONFIG_RULES_MAX_LIMIT = 1e3;
-const CONFIG_RULES_DEFAULT_LIMIT = 100;
-const CONFIG_CONTRACTS_MAX_LIMIT = 1e3;
-const CONFIG_CONTRACTS_DEFAULT_LIMIT = 1e3;
-/** Validate cursor is a valid base64url-encoded JSON object.
-* Domain layer handles semantic validation of cursor fields. */
-function isValidBase64urlJson(val) {
-	try {
-		const decoded = Buffer.from(val, "base64url").toString("utf8");
-		JSON.parse(decoded);
-		return true;
-	} catch {
-		return false;
-	}
-}
-const csvArray = (schema) => z$1.preprocess((value) => {
-	if (value === void 0) return void 0;
-	if (Array.isArray(value)) {
-		if (value.some((item) => typeof item !== "string")) return value;
-		return value.flatMap((item) => item.split(",")).map((item) => item.trim()).filter((item) => item.length > 0);
-	}
-	if (typeof value === "string") return value.split(",").map((item) => item.trim()).filter((item) => item.length > 0);
-	return value;
-}, z$1.array(schema)).optional();
-const PaginationQueryParams = z$1.object({
-	cursor: z$1.string().optional().refine((val) => {
-		if (!val) return true;
-		return isValidBase64urlJson(val);
-	}, { message: "Invalid cursor format. Must be a valid base64url-encoded cursor object" }).meta({
-		description: "Pagination cursor in base64url-encoded format",
-		example: "eyJzaWRlIjoic2VsbCIsImN1cnJlbnRQcmljZSI6IjEwMDAwMDAwMDAwMDAwMDAwMDAiLCJibG9ja051bWJlciI6MSwiYXNzZXRzIjoiMTAwMDAwMDAwMDAwMDAwMDAwMCIsImhhc2giOiIweGRmZDY4NTllM2UwODJkMTkzODlhMWFlYzFiZGFkN2U4ZDkyZDk2YjFhYTc5NDBkYTkxYTMxMjVkMzFlM2JlNWIiLCJ0b3RhbFJldHVybmVkIjoxMCwibm93IjoxNjAwMDAwMDAwfQ"
-	}),
-	limit: z$1.string().regex(/^[1-9]\d*$/, { message: "Limit must be a positive integer" }).transform((val) => Number.parseInt(val, 10)).pipe(z$1.number().max(MAX_LIMIT, { message: `Limit cannot exceed ${MAX_LIMIT}` })).optional().default(DEFAULT_LIMIT$4).meta({
-		description: `Limit maximum: ${MAX_LIMIT}. Default: ${DEFAULT_LIMIT$4}`,
-		example: 10
-	})
-});
-const ConfigRuleTypes = z$1.enum([
-	"maturity",
-	"callback",
-	"loan_token"
-]);
-const GetConfigRulesQueryParams = z$1.object({
-	cursor: z$1.string().regex(/^(maturity|callback|loan_token):[1-9]\d*:.+$/, { message: "Cursor must be in the format type:chain_id:<value>" }).optional().meta({
-		description: "Pagination cursor in type:chain_id:<value> format",
-		example: "maturity:1:1730415600:end_of_next_month"
-	}),
-	limit: z$1.string().regex(/^[1-9]\d*$/, { message: "Limit must be a positive integer" }).transform((val) => Number.parseInt(val, 10)).pipe(z$1.number().max(CONFIG_RULES_MAX_LIMIT, { message: `Limit cannot exceed ${CONFIG_RULES_MAX_LIMIT}` })).optional().default(CONFIG_RULES_DEFAULT_LIMIT).meta({
-		description: `Limit maximum: ${CONFIG_RULES_MAX_LIMIT}. Default: ${CONFIG_RULES_DEFAULT_LIMIT}`,
-		example: 100
-	}),
-	types: csvArray(ConfigRuleTypes).meta({
-		description: "Filter by rule types (comma-separated).",
-		example: "maturity,loan_token"
-	}),
-	chains: csvArray(z$1.string().regex(/^[1-9]\d*$/, { message: "Chain must be a positive integer" }).transform((val) => Number.parseInt(val, 10))).meta({
-		description: "Filter by chain IDs (comma-separated).",
-		example: "1,8453"
-	})
-});
-const GetConfigContractsQueryParams = z$1.object({
-	cursor: z$1.string().regex(/^[1-9]\d*:0x[a-fA-F0-9]{40}$/, { message: "Cursor must be in the format chain_id:0x..." }).optional().meta({
-		description: "Pagination cursor in chain_id:address format (lowercase address).",
-		example: "1:0xa0b86991c6218b36c1d19d4a2e9eb0ce3606eb48"
-	}),
-	limit: z$1.string().regex(/^[1-9]\d*$/, { message: "Limit must be a positive integer" }).transform((val) => Number.parseInt(val, 10)).pipe(z$1.number().max(CONFIG_CONTRACTS_MAX_LIMIT, { message: `Limit cannot exceed ${CONFIG_CONTRACTS_MAX_LIMIT}` })).optional().default(CONFIG_CONTRACTS_DEFAULT_LIMIT).meta({
-		description: `Limit maximum: ${CONFIG_CONTRACTS_MAX_LIMIT}. Default: ${CONFIG_CONTRACTS_DEFAULT_LIMIT}`,
-		example: 1e3
-	}),
-	chains: csvArray(z$1.string().regex(/^[1-9]\d*$/, { message: "Chain must be a positive integer" }).transform((val) => Number.parseInt(val, 10))).meta({
-		description: "Filter by chain IDs (comma-separated).",
-		example: "1,8453"
-	})
-});
-const GetOffersQueryParams = z$1.object({
-	...PaginationQueryParams.shape,
-	side: z$1.enum(["buy", "sell"]).optional().meta({
-		description: "Side of the offer. Required when using obligation_id.",
-		example: "buy"
-	}),
-	obligation_id: z$1.string().regex(/^0x[a-fA-F0-9]{64}$/, { error: "Obligation id must be a valid 32-byte hex string" }).transform((val) => val.toLowerCase()).optional().meta({
-		description: "Offers obligation id. Required when not using maker.",
-		example: "0x1234567890123456789012345678901234567890123456789012345678901234"
-	}),
-	maker: z$1.string().regex(/^0x[a-fA-F0-9]{40}$/, { error: "Maker must be a valid 20-byte address" }).transform((val) => val.toLowerCase()).optional().meta({
-		description: "Maker address to filter offers by. Alternative to obligation_id + side.",
-		example: "0x7b093658BE7f90B63D7c359e8f408e503c2D9401"
-	})
-}).superRefine((val, ctx) => {
-	const hasObligation = val.obligation_id !== void 0;
-	const hasSide = val.side !== void 0;
-	const hasMaker = val.maker !== void 0;
-	if (hasMaker && (hasObligation || hasSide)) {
-		ctx.addIssue({
-			code: "custom",
-			message: "Cannot use both maker and obligation_id/side parameters"
-		});
-		return;
-	}
-	if (hasMaker) return;
-	if (!hasObligation || !hasSide) ctx.addIssue({
-		code: "custom",
-		message: "Must provide either maker or both obligation_id and side"
-	});
-});
-const GetObligationsQueryParams = z$1.object({
-	...PaginationQueryParams.shape,
-	cursor: z$1.string().optional().meta({
-		description: "Obligation id cursor",
-		example: "0x1234567890123456789012345678901234567890123456789012345678901234"
+		description: "Maximum number of obligations to return."
 	}),
-	chains: csvArray(z$1.string().regex(/^[1-9]\d*$/, { message: "Chain must be a positive integer" }).transform((val) => Number.parseInt(val, 10))).meta({
+	ApiQuery({
+		name: "chains",
+		type: ["number"],
+		required: false,
+		example: "1,8453",
 		description: "Filter by chain IDs (comma-separated).",
-		example: "1,8453"
+		style: "form",
+		explode: false
 	}),
-	loan_tokens: csvArray(z$1.string().regex(/^0x[a-fA-F0-9]{40}$/, { error: "Loan token must be a valid 20-byte address" }).transform((val) => val.toLowerCase())).meta({
+	ApiQuery({
+		name: "loan_tokens",
+		type: ["string"],
+		required: false,
+		example: "0xC9A9C45C0eB717f8b5F193Af6bAa05A1c0Ac5078,0x34Cf890dB685FC536E05652FB41f02090c3fb751",
 		description: "Filter by loan token addresses (comma-separated).",
-		example: "0xC9A9C45C0eB717f8b5F193Af6bAa05A1c0Ac5078,0x34Cf890dB685FC536E05652FB41f02090c3fb751"
-	}),
-	collateral_tokens: csvArray(z$1.string().regex(/^0x[a-fA-F0-9]{40}$/, { error: "Collateral token must be a valid 20-byte address" }).transform((val) => val.toLowerCase())).meta({
-		description: "Filter by collateral tokens (comma-separated, matches any collateral).",
-		example: "0x34Cf890dB685FC536E05652FB41f02090c3fb751,0xC9A9C45C0eB717f8b5F193Af6bAa05A1c0Ac5078"
-	}),
-	maturities: csvArray(z$1.string().regex(/^[1-9]\d*$/, { message: "Maturity must be a positive integer" }).transform((val) => Number.parseInt(val, 10))).meta({
-		description: "Filter by exact maturity timestamps (comma-separated, unix seconds).",
-		example: "1761922800,1764524800"
-	})
-});
-const GetObligationParams = z$1.object({ obligation_id: z$1.string({ error: "Obligation id is required and must be a valid 32-byte hex string" }).regex(/^0x[a-fA-F0-9]{64}$/, { error: "Obligation id must be a valid 32-byte hex string" }).transform((val) => val.toLowerCase()).meta({
-	description: "Obligation id",
-	example: "0x1234567890123456789012345678901234567890123456789012345678901234"
-}) });
-/** Validate a book cursor format: {side, lastPrice, offersCursor} */
-function isValidBookCursor(cursorString) {
-	const isNumericString = (value) => typeof value === "string" && /^-?\d+$/.test(value);
-	try {
-		const v = JSON.parse(Buffer.from(cursorString, "base64url").toString("utf8"));
-		return (v?.side === "buy" || v?.side === "sell") && isNumericString(v?.lastPrice) && (v?.offersCursor === null || typeof v?.offersCursor === "string");
-	} catch {
-		return false;
-	}
-}
-const BookPaginationQueryParams = z$1.object({
-	cursor: z$1.string().optional().refine((value) => {
-		if (!value) return true;
-		return isValidBookCursor(value);
-	}, { message: "Invalid cursor format. Must be a valid base64url-encoded book cursor object" }).meta({
-		description: "Pagination cursor in base64url-encoded format for book levels",
-		example: "eyJzaWRlIjoiYnV5IiwibGFzdFJhdGUiOiIxMDAwMDAwMDAwMDAwMDAwMDAwIiwib2ZmZXJzQ3Vyc29yIjpudWxsfQ"
+		style: "form",
+		explode: false
 	}),
-	limit: z$1.string().regex(/^[1-9]\d*$/, { message: "Limit must be a positive integer" }).transform((val) => Number.parseInt(val, 10)).pipe(z$1.number().max(MAX_LIMIT, { message: `Limit cannot exceed ${MAX_LIMIT}` })).optional().default(DEFAULT_LIMIT$4).meta({
-		description: `Limit maximum: ${MAX_LIMIT}. Default: ${DEFAULT_LIMIT$4}`,
-		example: 10
-	})
-});
-const HealthQueryParams = z$1.object({ strict: z$1.enum([
-	"true",
-	"false",
-	"1",
-	"0"
-]).transform((value) => value === "true" || value === "1").optional().meta({
-	description: "Enable strict mode to fail health checks when initialization is incomplete.",
-	example: "true"
-}) });
-const GetBookParams = z$1.object({
-	...BookPaginationQueryParams.shape,
-	obligation_id: z$1.string({ error: "Obligation id is required and must be a valid 32-byte hex string" }).regex(/^0x[a-fA-F0-9]{64}$/, { error: "Obligation id must be a valid 32-byte hex string" }).transform((val) => val.toLowerCase()).meta({
-		description: "Obligation id",
-		example: "0x1234567890123456789012345678901234567890123456789012345678901234"
+	ApiQuery({
+		name: "collateral_tokens",
+		type: ["string"],
+		required: false,
+		example: "0x34Cf890dB685FC536E05652FB41f02090c3fb751,0xC9A9C45C0eB717f8b5F193Af6bAa05A1c0Ac5078",
+		description: "Filter by collateral tokens (comma-separated, matches any collateral).",
+		style: "form",
+		explode: false
 	}),
-	side: z$1.enum(["buy", "sell"]).meta({
-		description: "Side of the book (buy or sell).",
-		example: "buy"
-	})
-});
-const ValidateOffersBody = z$1.object({ offers: z$1.array(z$1.unknown()).min(1, { message: "'offers' must contain at least 1 offer" }) }).strict();
-const CallbackTypesBody = z$1.object({ callbacks: z$1.array(z$1.object({
-	chain_id: z$1.number().int().positive().meta({
-		description: "Chain id.",
-		example: 1
+	ApiQuery({
+		name: "maturities",
+		type: ["number"],
+		required: false,
+		example: "1761922800,1764524800",
+		description: "Filter by exact maturity timestamps (comma-separated, unix seconds).",
+		style: "form",
+		explode: false
 	}),
-	addresses: z$1.array(z$1.string().regex(/^0x[a-fA-F0-9]{40}$/, { error: "Callback address must be a valid 20-byte address" }).transform((val) => val.toLowerCase())).meta({
-		description: "Callback contract addresses.",
-		example: ["0x1111111111111111111111111111111111111111", "0x3333333333333333333333333333333333333333"]
-	})
-}).strict()) }).strict();
-const GetUserPositionsParams = z$1.object({
-	...PaginationQueryParams.shape,
-	user_address: z$1.string().regex(/^0x[a-fA-F0-9]{40}$/, { error: "User address must be a valid 20-byte address" }).transform((val) => val.toLowerCase()).meta({
-		description: "User address to get positions for",
-		example: "0x7b093658BE7f90B63D7c359e8f408e503c2D9401"
+	ApiResponse({
+		status: 200,
+		description: "Success",
+		type: ObligationListResponse
 	})
-});
-const schemas = {
-	get_health: HealthQueryParams,
-	get_health_collectors: HealthQueryParams,
-	get_health_chains: HealthQueryParams,
-	get_config_contracts: GetConfigContractsQueryParams,
-	get_config_rules: GetConfigRulesQueryParams,
-	get_offers: GetOffersQueryParams,
-	get_obligations: GetObligationsQueryParams,
-	get_obligation: GetObligationParams,
-	get_book: GetBookParams,
-	validate_offers: ValidateOffersBody,
-	callback_types: CallbackTypesBody,
-	get_user_positions: GetUserPositionsParams
-};
-function parse(action, query) {
-	return schemas[action].parse(query);
-}
-function safeParse(action, query, error) {
-	return schemas[action].safeParse(query, { error });
-}
-
-//#endregion
-//#region src/api/Controllers/getBook.ts
-async function getBook(params, db) {
-	const logger = getLogger();
-	const result = safeParse("get_book", params, (issue) => issue.message);
-	if (!result.success) return failure(result.error);
-	const query = result.data;
-	try {
-		const { levels, nextCursor } = await db.book.get({
-			side: query.side,
-			obligationId: query.obligation_id,
-			cursor: query.cursor,
-			limit: query.limit
-		});
-		return success({
-			data: levels.map(from$5),
-			cursor: nextCursor
-		});
-	} catch (err) {
-		logger.error({
-			err,
-			msg: "Error get book",
-			errorMessage: err instanceof Error ? err.message : String(err),
-			errorStack: err instanceof Error ? err.stack : void 0
-		});
-		return failure(err);
-	}
-}
-
-//#endregion
-//#region src/api/Controllers/getConfigContracts.ts
-const CONFIG_CONTRACT_NAMES = [
-	"mempool",
-	"multicall",
-	"v2"
-];
-/**
-* Returns contract addresses used by indexers (mempool, v2) plus multicall per chain.
-* @param query - Raw query parameters containing optional chain filters.
-* @param chainRegistry - The chain registry instance. {@link ChainRegistry.ChainRegistry}
-* @returns The indexer contract configuration. {@link ApiPayload.Payload<ConfigContract[]>}
-*/
-async function getConfigContracts(query, chainRegistry) {
-	const parsed = safeParse("get_config_contracts", query ?? {});
-	if (!parsed.success) return failure(parsed.error);
-	const { chains: chainsFilter, cursor, limit } = parsed.data;
-	const chainFilter = chainsFilter?.length ? new Set(chainsFilter) : null;
-	const contracts = [];
-	const seenAddresses = /* @__PURE__ */ new Set();
-	for (const chain of chainRegistry.list()) {
-		if (chainFilter && !chainFilter.has(chain.id)) continue;
-		const mempool = chain.custom?.mempool?.address;
-		if (!mempool) return failure(new InternalServerError(`Missing mempool address for chain ${chain.id}.`));
-		const multicall = chain.contracts?.multicall3?.address;
-		if (!multicall) return failure(new InternalServerError(`Missing multicall3 address for chain ${chain.id}.`));
-		const v2 = chain.custom?.morpho?.address;
-		if (!v2) return failure(new InternalServerError(`Missing morpho address for chain ${chain.id}.`));
-		const chainContracts = [
-			{
-				chain_id: chain.id,
-				name: "mempool",
-				address: mempool
-			},
-			{
-				chain_id: chain.id,
-				name: "multicall",
-				address: multicall
-			},
-			{
-				chain_id: chain.id,
-				name: "v2",
-				address: v2
-			}
-		];
-		for (const contract of chainContracts) {
-			const cursorKey = `${contract.chain_id}:${contract.address.toLowerCase()}`;
-			if (seenAddresses.has(cursorKey)) return failure(new InternalServerError(`Duplicate contract address ${contract.address} for chain ${chain.id}.`));
-			seenAddresses.add(cursorKey);
-			contracts.push(contract);
-		}
-	}
-	contracts.sort((a, b) => {
-		if (a.chain_id !== b.chain_id) return a.chain_id - b.chain_id;
-		const addressCompare = a.address.toLowerCase().localeCompare(b.address.toLowerCase());
-		if (addressCompare !== 0) return addressCompare;
-		return a.name.localeCompare(b.name);
-	});
-	let cursorContract = null;
-	if (cursor) try {
-		cursorContract = parseCursor$1(cursor);
-	} catch (err) {
-		return failure(err);
-	}
-	const startIndex = cursorContract ? findStartIndex$1(contracts, cursorContract) : 0;
-	const page = contracts.slice(startIndex, startIndex + limit);
-	const nextCursor = startIndex + limit < contracts.length && page.length > 0 ? formatCursor$1(page.at(-1)) : null;
-	return success({
-		data: page,
-		cursor: nextCursor
-	});
-}
-function parseCursor$1(cursor) {
-	const [chain, address] = cursor.split(":", 2);
-	if (!chain || !address) throw new BadRequestError("Cursor must be in the format chain_id:0x...");
-	return {
-		chain_id: Number.parseInt(chain, 10),
-		address: address.toLowerCase()
-	};
-}
-function formatCursor$1(contract) {
-	return `${contract.chain_id}:${contract.address.toLowerCase()}`;
-}
-function findStartIndex$1(contracts, cursor) {
-	let low = 0;
-	let high = contracts.length;
-	while (low < high) {
-		const mid = Math.floor((low + high) / 2);
-		const current = contracts[mid];
-		if (compareContract(current, cursor) <= 0) low = mid + 1;
-		else high = mid;
-	}
-	return low;
-}
-function compareContract(contract, cursor) {
-	if (contract.chain_id !== cursor.chain_id) return contract.chain_id - cursor.chain_id;
-	return contract.address.toLowerCase().localeCompare(cursor.address.toLowerCase());
-}
-
-//#endregion
-//#region src/gatekeeper/GateConfig.ts
-/**
-* Returns the callback configuration for a given chain and callback type, if it exists.
-*
-* @param chain - Chain name for which to read the validation configuration
-* @param type - Callback type to retrieve
-* @returns The matching callback configuration or undefined if not configured
-*/
-function getCallback(chain, type) {
-	return configs[chain].callbacks?.find((c) => c.type === type);
-}
-/**
-* Attempts to infer the configured callback type from a callback address on a chain.
-* Skips the empty callback type as it does not carry addresses.
-*
-* @param chain - Chain name for which to infer the callback type
-* @param address - Callback contract address
-* @returns The callback type when found, otherwise undefined
-*/
-function getCallbackType(chain, address) {
-	return configs[chain].callbacks?.find((c) => c.type !== Type$1.BuyWithEmptyCallback && c.addresses.includes(address?.toLowerCase()))?.type;
-}
-/**
-* Returns the list of allowed non-empty callback addresses for a chain.
-*
-* @param chain - Chain name
-* @returns Array of allowed callback addresses (lowercased). Empty when none configured
-*/
-const getCallbackAddresses = (chain) => {
-	return configs[chain].callbacks?.filter((c) => c.type !== Type$1.BuyWithEmptyCallback).flatMap((c) => c.addresses) ?? [];
-};
-const assets = {
-	[ChainId.ETHEREUM.toString()]: [
-		"0xA0b86991c6218b36c1d19D4a2e9Eb0cE3606eB48",
-		"0x6B175474E89094C44Da98b954EedeAC495271d0F",
-		"0xC02aaA39b223FE8D0A0e5C4F27eAD9083C756Cc2",
-		"0x2260FAC5E5542a773Aa44fBCfeDf7C193bc2C599"
-	],
-	[ChainId.BASE.toString()]: [
-		"0x833589fCD6eDb6E08f4c7C32D4f71b54bdA02913",
-		"0x50c5725949A6F0c72E6C4a641F24049A917DB0Cb",
-		"0x4200000000000000000000000000000000000006",
-		"0x2260FAC5E5542a773Aa44fBCfeDf7C193bc2C599"
-	],
-	[ChainId["ETHEREUM-VIRTUAL-TESTNET"].toString()]: [
-		"0xA0b86991c6218b36c1d19D4a2e9Eb0cE3606eB48",
-		"0x6B175474E89094C44Da98b954EedeAC495271d0F",
-		"0xC02aaA39b223FE8D0A0e5C4F27eAD9083C756Cc2",
-		"0x2260FAC5E5542a773Aa44fBCfeDf7C193bc2C599",
-		"0xce79ddb3152d52ff8fe65a4c7e058b035fcb560a"
-	],
-	[ChainId.ANVIL.toString()]: [
-		"0xA0b86991c6218b36c1d19D4a2e9Eb0cE3606eB48",
-		"0x6B175474E89094C44Da98b954EedeAC495271d0F",
-		"0xC02aaA39b223FE8D0A0e5C4F27eAD9083C756Cc2",
-		"0x2260FAC5E5542a773Aa44fBCfeDf7C193bc2C599"
-	]
+], ObligationsController.prototype, "getObligations", null);
+__decorate([
+	ApiOperation({
+		methods: ["get"],
+		path: "/v1/obligations/{obligationId}",
+		summary: "Get an obligation",
+		description: "Returns an obligation by its id."
+	}),
+	ApiParam({
+		name: "obligationId",
+		type: "string",
+		example: "0x12590ae1aee324a005be565f3bcdd16dbf8daf7969b26c181c8b8f467dad9f67",
+		description: "Obligation id."
+	}),
+	ApiResponse({
+		status: 200,
+		description: "Success",
+		type: ObligationSingleSuccessResponse
+	})
+], ObligationsController.prototype, "getObligation", null);
+ObligationsController = __decorate([ApiTags("Markets"), ApiResponse({
+	status: 400,
+	description: "Bad Request",
+	type: BadRequestResponse
+})], ObligationsController);
+let UsersController = class UsersController {
+	async getUserPositions() {}
 };
-const configs = {
-	ethereum: {
-		callbacks: [
-			{
-				type: Type$1.BuyVaultV1Callback,
-				addresses: ["0x3333333333333333333333333333333333333333", "0x4444444444444444444444444444444444444444"],
-				vaultFactories: ["0xA9c3D3a366466Fa809d1Ae982Fb2c46E5fC41101", "0x1897A8997241C1cD4bD0698647e4EB7213535c24"]
-			},
-			{
-				type: Type$1.SellERC20Callback,
-				addresses: ["0x1111111111111111111111111111111111111111", "0x2222222222222222222222222222222222222222"]
-			},
-			{ type: Type$1.BuyWithEmptyCallback }
-		],
-		maturities: [MaturityType.EndOfMonth, MaturityType.EndOfNextMonth]
-	},
-	base: {
-		callbacks: [
-			{
-				type: Type$1.BuyVaultV1Callback,
-				addresses: ["0x3333333333333333333333333333333333333333", "0x4444444444444444444444444444444444444444"],
-				vaultFactories: ["0xA9c3D3a366466Fa809d1Ae982Fb2c46E5fC41101", "0xFf62A7c278C62eD665133147129245053Bbf5918"]
-			},
-			{
-				type: Type$1.SellERC20Callback,
-				addresses: ["0x1111111111111111111111111111111111111111", "0x2222222222222222222222222222222222222222"]
-			},
-			{ type: Type$1.BuyWithEmptyCallback }
-		],
-		maturities: [MaturityType.EndOfMonth, MaturityType.EndOfNextMonth]
-	},
-	"ethereum-virtual-testnet": {
-		callbacks: [
-			{
-				type: Type$1.BuyVaultV1Callback,
-				addresses: ["0x3333333333333333333333333333333333333333", "0x4444444444444444444444444444444444444444"],
-				vaultFactories: ["0xA9c3D3a366466Fa809d1Ae982Fb2c46E5fC41101", "0x1897A8997241C1cD4bD0698647e4EB7213535c24"]
-			},
-			{
-				type: Type$1.SellERC20Callback,
-				addresses: ["0x1111111111111111111111111111111111111111", "0x2222222222222222222222222222222222222222"]
-			},
-			{ type: Type$1.BuyWithEmptyCallback }
+__decorate([
+	ApiOperation({
+		methods: ["get"],
+		path: "/v1/users/{userAddress}/positions",
+		summary: "Get user positions",
+		description: "Returns positions for a user with reserved balance. The reserved balance is the amount locked by active offers (max lot upper - offset - consumed)."
+	}),
+	ApiParam({
+		name: "userAddress",
+		type: "string",
+		example: "0x7b093658BE7f90B63D7c359e8f408e503c2D9401",
+		description: "User address to get positions for."
+	}),
+	ApiQuery({
+		name: "cursor",
+		type: "string",
+		example: offerCursorExample,
+		description: "Pagination cursor in base64url-encoded format."
+	}),
+	ApiQuery({
+		name: "limit",
+		type: "number",
+		example: 10,
+		description: "Maximum number of positions to return."
+	}),
+	ApiResponse({
+		status: 200,
+		description: "Success",
+		type: PositionListResponse
+	})
+], UsersController.prototype, "getUserPositions", null);
+UsersController = __decorate([ApiTags("Make"), ApiResponse({
+	status: 400,
+	description: "Bad Request",
+	type: BadRequestResponse
+})], UsersController);
+const OpenApi = async () => {
+	return await generateDocument({
+		controllers: [
+			BooksController,
+			ConfigContractsController,
+			ConfigRulesController,
+			OffersController,
+			ObligationsController,
+			HealthController,
+			UsersController,
+			ValidateController
 		],
-		maturities: [MaturityType.EndOfMonth, MaturityType.EndOfNextMonth]
-	},
-	anvil: {
-		callbacks: [
-			{
-				type: Type$1.BuyVaultV1Callback,
-				addresses: ["0x3333333333333333333333333333333333333333", "0x4444444444444444444444444444444444444444"],
-				vaultFactories: ["0xA9c3D3a366466Fa809d1Ae982Fb2c46E5fC41101", "0x1897A8997241C1cD4bD0698647e4EB7213535c24"]
-			},
-			{
-				type: Type$1.SellERC20Callback,
-				addresses: ["0x1111111111111111111111111111111111111111", "0x2222222222222222222222222222222222222222"]
+		document: {
+			openapi: "3.1.0",
+			info: {
+				title: "Router API",
+				version: "1.0.0",
+				description: "API for the Morpho Router"
 			},
-			{ type: Type$1.BuyWithEmptyCallback }
-		],
-		maturities: [MaturityType.EndOfMonth, MaturityType.EndOfNextMonth]
-	}
-};
-
-//#endregion
-//#region src/gatekeeper/ConfigRules.ts
-/**
-* Build the configured rules (maturities + callback addresses + loan tokens) for the provided chains.
-* @param chains - Chains to include in the configured rules.
-* @returns Sorted list of config rules.
-*/
-function buildConfigRules(chains) {
-	const rules = [];
-	for (const chain of chains) {
-		const config = configs[chain.name];
-		const maturities = config.maturities ?? [];
-		for (const maturityName of maturities) rules.push({
-			type: "maturity",
-			chain_id: chain.id,
-			name: maturityName,
-			timestamp: from$16(maturityName)
-		});
-		const callbacks = config.callbacks ?? [];
-		for (const callback of callbacks) {
-			if (callback.type === Type$1.BuyWithEmptyCallback) continue;
-			if (!("addresses" in callback)) continue;
-			for (const address of callback.addresses) rules.push({
-				type: "callback",
-				chain_id: chain.id,
-				address: normalizeAddress(address),
-				callback_type: callback.type
-			});
-		}
-		const loanTokens = assets[chain.id.toString()] ?? [];
-		for (const address of loanTokens) rules.push({
-			type: "loan_token",
-			chain_id: chain.id,
-			address: normalizeAddress(address)
-		});
-	}
-	rules.sort(compareConfigRules);
-	return rules;
-}
-/**
-* Compute a stable checksum for the provided configured rules.
-* @param rules - Configured rules to checksum.
-* @returns MD5 checksum.
-*/
-function buildConfigRulesChecksum(rules) {
-	const hash = createHash("md5");
-	const orderedRules = [...rules].sort(compareConfigRules);
-	for (const rule of orderedRules) {
-		if (rule.type === "maturity") {
-			hash.update(`maturity:${rule.chain_id}:${rule.name}:${rule.timestamp}\n`);
-			continue;
-		}
-		if (rule.type === "callback") {
-			hash.update(`callback:${rule.chain_id}:${rule.callback_type}:${rule.address}\n`);
-			continue;
+			servers: [{
+				url: "https://router.morpho.dev",
+				description: "Production server"
+			}, {
+				url: "http://localhost:7891",
+				description: "Local development server"
+			}],
+			tags: [
+				{
+					name: "Markets",
+					description: "Read-only endpoints to discover markets, order books and fetch current offers."
+				},
+				{
+					name: "Make",
+					description: "Utilities to ease making offers."
+				},
+				{
+					name: "System",
+					description: "Router configuration and health monitoring."
+				}
+			]
 		}
-		hash.update(`loan_token:${rule.chain_id}:${rule.address}\n`);
-	}
-	return hash.digest("hex");
-}
-function normalizeAddress(address) {
-	return address.toLowerCase();
-}
-function compareConfigRules(left, right) {
-	if (left.chain_id !== right.chain_id) return left.chain_id - right.chain_id;
-	if (left.type !== right.type) return left.type.localeCompare(right.type);
-	if (left.type === "maturity" && right.type === "maturity") return left.timestamp - right.timestamp;
-	if (left.type === "callback" && right.type === "callback") {
-		if (left.callback_type !== right.callback_type) return left.callback_type.localeCompare(right.callback_type);
-		return left.address.localeCompare(right.address);
-	}
-	if (left.type === "loan_token" && right.type === "loan_token") return left.address.localeCompare(right.address);
-	return 0;
-}
+	});
+};
 
 //#endregion
-//#region src/api/Controllers/getConfigRules.ts
+//#region src/api/Schema/PositionResponse.ts
+var PositionResponse_exports = /* @__PURE__ */ __exportAll({ from: () => from$2 });
 /**
-* Returns configured rules for the configured chains.
-* @param query - Raw query parameters containing filters/cursor/limit.
-* @param chains - Chains to include in the configured rules.
-* @returns Config rules response payload. {@link ApiPayload.Payload}
-*/
-async function getConfigRules(query, chains) {
-	const parsed = safeParse("get_config_rules", query ?? {});
-	if (!parsed.success) return failure(parsed.error);
-	const { cursor, limit, types, chains: chainIds } = parsed.data;
-	const typeFilter = types?.length ? new Set(types) : null;
-	const chainFilter = chainIds?.length ? new Set(chainIds) : null;
-	const filteredRules = buildConfigRules(chains).filter((rule) => {
-		if (chainFilter && !chainFilter.has(rule.chain_id)) return false;
-		if (typeFilter && !typeFilter.has(rule.type)) return false;
-		return true;
-	});
-	const checksum = buildConfigRulesChecksum(filteredRules);
-	let cursorRule = null;
-	if (cursor) try {
-		cursorRule = parseCursor(cursor);
-	} catch (err) {
-		return failure(err);
-	}
-	if (cursorRule && typeFilter && !typeFilter.has(cursorRule.type)) return failure(new BadRequestError("Cursor type must match requested rule types"));
-	if (cursorRule && chainFilter && !chainFilter.has(cursorRule.chain_id)) return failure(new BadRequestError("Cursor chain_id must match requested chains"));
-	const startIndex = cursorRule ? findStartIndex(filteredRules, cursorRule) : 0;
-	const page = filteredRules.slice(startIndex, startIndex + limit);
-	const nextCursor = startIndex + limit < filteredRules.length && page.length > 0 ? formatCursor(page.at(-1)) : null;
-	const response = success({
-		data: page,
-		cursor: nextCursor
-	});
-	response.body.meta.checksum = checksum;
-	return response;
-}
-function formatCursor(rule) {
-	if (rule.type === "maturity") return `maturity:${rule.chain_id}:${rule.timestamp}:${rule.name}`;
-	if (rule.type === "callback") return `callback:${rule.chain_id}:${rule.callback_type}:${rule.address.toLowerCase()}`;
-	return `loan_token:${rule.chain_id}:${rule.address.toLowerCase()}`;
-}
-function parseCursor(cursor) {
-	const [type, chain, ...rest] = cursor.split(":");
-	if (!type || !chain || rest.length === 0) throw new BadRequestError("Cursor must be in the format type:chain_id:<value>");
-	if (!isConfigRuleType(type)) throw new BadRequestError("Cursor has an invalid rule type");
-	const chain_id = Number.parseInt(chain, 10);
-	if (!Number.isFinite(chain_id)) throw new BadRequestError("Cursor has an invalid chain_id");
-	if (type === "maturity") {
-		const timestampValue = Number.parseInt(rest[0] ?? "", 10);
-		const nameValue = rest.slice(1).join(":");
-		if (!Number.isFinite(timestampValue) || nameValue.length === 0) throw new BadRequestError("Cursor must be in the format maturity:chain_id:timestamp:name");
-		if (!isMaturityType(nameValue)) throw new BadRequestError("Cursor has an invalid maturity name");
-		return {
-			type,
-			chain_id,
-			timestamp: parseMaturity(timestampValue),
-			name: nameValue
-		};
-	}
-	if (type === "callback") {
-		const callbackTypeValue = rest[0] ?? "";
-		const addressValue = rest.slice(1).join(":");
-		if (!callbackTypeValue || !addressValue) throw new BadRequestError("Cursor must be in the format callback:chain_id:callback_type:address");
-		if (!isCallbackType(callbackTypeValue)) throw new BadRequestError("Cursor has an invalid callback type");
-		return {
-			type,
-			chain_id,
-			callback_type: callbackTypeValue,
-			address: parseAddress(addressValue, "Cursor address")
-		};
-	}
-	const addressValue = rest.join(":");
-	if (!addressValue) throw new BadRequestError("Cursor must be in the format loan_token:chain_id:address");
+* Creates a `PositionResponse` from a `PositionWithReserved`.
+* @param position - {@link PositionWithReserved}
+* @returns The created `PositionResponse`. {@link PositionResponse}
+*/
+function from$2(position) {
 	return {
-		type,
-		chain_id,
-		address: parseAddress(addressValue, "Cursor address")
+		chain_id: position.chainId,
+		contract: position.contract,
+		user: position.user,
+		reserved: position.reserved.toString(),
+		block_number: position.blockNumber
 	};
 }
-function findStartIndex(rules, cursor) {
-	let low = 0;
-	let high = rules.length;
-	while (low < high) {
-		const mid = Math.floor((low + high) / 2);
-		const current = rules[mid];
-		if (compareConfigRules(current, cursor) <= 0) low = mid + 1;
-		else high = mid;
-	}
-	return low;
-}
-function parseAddress(address, label) {
-	if (!/^0x[a-fA-F0-9]{40}$/.test(address)) throw new BadRequestError(`${label} must be a valid 20-byte address`);
-	return address.toLowerCase();
-}
-function isConfigRuleType(value) {
-	return value === "maturity" || value === "callback" || value === "loan_token";
-}
-function isMaturityType(value) {
-	return Object.values(MaturityType).includes(value);
-}
-function parseMaturity(value) {
-	try {
-		return from$16(value);
-	} catch (err) {
-		throw new BadRequestError(err instanceof Error ? err.message : "Invalid maturity timestamp");
-	}
-}
-function isCallbackType(value) {
-	if (value === Type$1.BuyWithEmptyCallback) return false;
-	return Object.values(Type$1).includes(value);
-}
 
 //#endregion
-//#region src/api/Controllers/getDocs.ts
-const __dirname = (() => {
+//#region src/api/Schema/requests.ts
+const MAX_LIMIT = 100;
+const DEFAULT_LIMIT$4 = 20;
+const CONFIG_RULES_MAX_LIMIT = 1e3;
+const CONFIG_RULES_DEFAULT_LIMIT = 100;
+const CONFIG_CONTRACTS_MAX_LIMIT = 1e3;
+const CONFIG_CONTRACTS_DEFAULT_LIMIT = 1e3;
+/** Validate cursor is a valid base64url-encoded JSON object.
+* Domain layer handles semantic validation of cursor fields. */
+function isValidBase64urlJson(val) {
 	try {
-		return dirname(fileURLToPath(import.meta.url));
+		const decoded = Buffer.from(val, "base64url").toString("utf8");
+		JSON.parse(decoded);
+		return true;
 	} catch {
-		return process.cwd();
+		return false;
 	}
-})();
-/**
-* Build the OpenAPI document for the router.
-* @returns OpenAPI document. {@link OpenAPIDocument}
-*/
-async function getSwaggerJson() {
-	return OpenApi();
-}
-/**
-* Render the API documentation HTML page.
-* @returns HTML page as string.
-*/
-async function getDocsHtml() {
-	const spec = await OpenApi();
-	return `<!DOCTYPE html>
-<html>
-  <head>
-    <meta charset="UTF-8">
-    <title>Router API Docs (Scalar)</title>
-    <script src="https://cdn.jsdelivr.net/npm/@scalar/api-reference"><\/script>
-    <style>
-      html, body { margin: 0; height: 100%; }
-      api-reference { height: 100%; width: 100%; }
-    </style>
-  </head>
-  <body>
-    <div id="api-container" style="height:100%;width:100%;"></div>
-    <script>
-      window.addEventListener('load', function () {
-        const spec = ${JSON.stringify(spec)};
-        Scalar.createApiReference('#api-container', { spec: { content: spec, hideModels: true } });
-      });
-    <\/script>
-  </body>
-</html>`;
-}
-/**
-* Finds the integrator.md file.
-* Handles source, bundled CLI, and Lambda scenarios.
-*/
-function findIntegratorMd() {
-	const candidates = [
-		resolve(__dirname, "../../../docs/integrator.md"),
-		resolve(__dirname, "../docs/integrator.md"),
-		resolve(process.cwd(), "docs/integrator.md")
-	];
-	for (const candidate of candidates) if (existsSync(candidate)) return candidate;
-	throw new Error(`integrator.md not found. Tried: ${candidates.join(", ")}`);
 }
-/**
-* Renders the integrator documentation as HTML.
-* @returns HTML page with the rendered markdown documentation.
-*/
-async function getIntegratorDocsHtml() {
-	return `<!DOCTYPE html>
-<html>
-  <head>
-    <meta charset="UTF-8">
-    <title>Documentation</title>
-    <style>
-      body { font-family: system-ui, sans-serif; max-width: 800px; margin: 0 auto; padding: 2rem; line-height: 1.6; }
-      pre { background: #f4f4f4; padding: 1rem; overflow-x: auto; }
-      code { background: #f4f4f4; padding: 0.2rem 0.4rem; }
-      a { color: #0066cc; }
-    </style>
-  </head>
-  <body>
-    <nav><a href="/docs/api">API Reference &rarr;</a></nav>
-    ${await marked(await readFile(findIntegratorMd(), "utf-8"))}
-  </body>
-</html>`;
+function isValidOfferHashCursor(val) {
+	return /^0x[a-f0-9]{64}$/i.test(val);
 }
-
-//#endregion
-//#region src/api/Controllers/getHealth.ts
-async function getHealth(query, db, chainRegistry) {
-	const logger = getLogger();
-	try {
-		const parsed = safeParse("get_health", query);
-		if (!parsed.success) return failure(parsed.error);
-		const snapshot = await create$16({
-			db,
-			chainRegistry
-		}).getSnapshot();
-		if (parsed.data.strict && !snapshot.initialized) return failure(new APIError(STATUS_CODE.INTERNAL_SERVER_ERROR, "Indexer block state is not initialized", "INTERNAL_SERVER_ERROR", toSnakeCase$1({
-			missingChains: snapshot.missingChains,
-			missingCollectors: snapshot.missingCollectors
-		})));
-		return success({ data: toSnakeCase$1({
-			status: snapshot.status,
-			initialized: snapshot.initialized,
-			missingChains: snapshot.missingChains,
-			missingCollectors: snapshot.missingCollectors
-		}) });
-	} catch (err) {
-		logger.error({
-			err,
-			msg: "Error getting health status",
-			errorMessage: err instanceof Error ? err.message : String(err),
-			errorStack: err instanceof Error ? err.stack : void 0
-		});
-		return failure(err);
+const csvArray = (schema) => z$1.preprocess((value) => {
+	if (value === void 0) return void 0;
+	if (Array.isArray(value)) {
+		if (value.some((item) => typeof item !== "string")) return value;
+		return value.flatMap((item) => item.split(",")).map((item) => item.trim()).filter((item) => item.length > 0);
 	}
-}
-async function getHealthChains(query, db, healthClients, chainRegistry) {
-	const logger = getLogger();
-	try {
-		const parsed = safeParse("get_health_chains", query);
-		if (!parsed.success) return failure(parsed.error);
-		const snapshot = await create$16({
-			db,
-			healthClients,
-			chainRegistry
-		}).getSnapshot();
-		if (parsed.data.strict && !snapshot.initialized) return failure(new APIError(STATUS_CODE.INTERNAL_SERVER_ERROR, "Indexer block state is not initialized", "INTERNAL_SERVER_ERROR", toSnakeCase$1({
-			missingChains: snapshot.missingChains,
-			missingCollectors: snapshot.missingCollectors
-		})));
-		const chains = snapshot.chains;
-		return success({ data: chains.map(({ chainId, localBlockNumber, remoteBlockNumber, updatedAt, initialized }) => toSnakeCase$1({
-			chainId,
-			localBlockNumber,
-			remoteBlockNumber,
-			updatedAt,
-			initialized
-		})) });
-	} catch (err) {
-		logger.error({
-			err,
-			msg: "Error getting health status for chains",
-			errorMessage: err instanceof Error ? err.message : String(err),
-			errorStack: err instanceof Error ? err.stack : void 0
+	if (typeof value === "string") return value.split(",").map((item) => item.trim()).filter((item) => item.length > 0);
+	return value;
+}, z$1.array(schema)).optional();
+const PaginationQueryParams = z$1.object({
+	cursor: z$1.string().optional().refine((val) => {
+		if (!val) return true;
+		return isValidBase64urlJson(val);
+	}, { message: "Invalid cursor format. Must be a valid base64url-encoded cursor object" }).meta({
+		description: "Pagination cursor in base64url-encoded format",
+		example: "eyJzaWRlIjoic2VsbCIsImN1cnJlbnRQcmljZSI6IjEwMDAwMDAwMDAwMDAwMDAwMDAiLCJibG9ja051bWJlciI6MSwiYXNzZXRzIjoiMTAwMDAwMDAwMDAwMDAwMDAwMCIsImhhc2giOiIweGRmZDY4NTllM2UwODJkMTkzODlhMWFlYzFiZGFkN2U4ZDkyZDk2YjFhYTc5NDBkYTkxYTMxMjVkMzFlM2JlNWIiLCJ0b3RhbFJldHVybmVkIjoxMCwibm93IjoxNjAwMDAwMDAwfQ"
+	}),
+	limit: z$1.string().regex(/^[1-9]\d*$/, { message: "Limit must be a positive integer" }).transform((val) => Number.parseInt(val, 10)).pipe(z$1.number().max(MAX_LIMIT, { message: `Limit cannot exceed ${MAX_LIMIT}` })).optional().default(DEFAULT_LIMIT$4).meta({
+		description: `Limit maximum: ${MAX_LIMIT}. Default: ${DEFAULT_LIMIT$4}`,
+		example: 10
+	})
+});
+const ConfigRuleTypes = z$1.enum([
+	"maturity",
+	"callback",
+	"loan_token",
+	"oracle"
+]);
+const GetConfigRulesQueryParams = z$1.object({
+	cursor: z$1.string().regex(/^(maturity|callback|loan_token|oracle):[1-9]\d*:.+$/, { message: "Cursor must be in the format type:chain_id:<value>" }).optional().meta({
+		description: "Pagination cursor in type:chain_id:<value> format",
+		example: "maturity:1:1730415600:end_of_next_month"
+	}),
+	limit: z$1.string().regex(/^[1-9]\d*$/, { message: "Limit must be a positive integer" }).transform((val) => Number.parseInt(val, 10)).pipe(z$1.number().max(CONFIG_RULES_MAX_LIMIT, { message: `Limit cannot exceed ${CONFIG_RULES_MAX_LIMIT}` })).optional().default(CONFIG_RULES_DEFAULT_LIMIT).meta({
+		description: `Limit maximum: ${CONFIG_RULES_MAX_LIMIT}. Default: ${CONFIG_RULES_DEFAULT_LIMIT}`,
+		example: 100
+	}),
+	types: csvArray(ConfigRuleTypes).meta({
+		description: "Filter by rule types (comma-separated).",
+		example: "maturity,loan_token,oracle"
+	}),
+	chains: csvArray(z$1.string().regex(/^[1-9]\d*$/, { message: "Chain must be a positive integer" }).transform((val) => Number.parseInt(val, 10))).meta({
+		description: "Filter by chain IDs (comma-separated).",
+		example: "1,8453"
+	})
+});
+const GetConfigContractsQueryParams = z$1.object({
+	cursor: z$1.string().regex(/^[1-9]\d*:0x[a-fA-F0-9]{40}$/, { message: "Cursor must be in the format chain_id:0x..." }).optional().meta({
+		description: "Pagination cursor in chain_id:address format (lowercase address).",
+		example: "1:0xa0b86991c6218b36c1d19d4a2e9eb0ce3606eb48"
+	}),
+	limit: z$1.string().regex(/^[1-9]\d*$/, { message: "Limit must be a positive integer" }).transform((val) => Number.parseInt(val, 10)).pipe(z$1.number().max(CONFIG_CONTRACTS_MAX_LIMIT, { message: `Limit cannot exceed ${CONFIG_CONTRACTS_MAX_LIMIT}` })).optional().default(CONFIG_CONTRACTS_DEFAULT_LIMIT).meta({
+		description: `Limit maximum: ${CONFIG_CONTRACTS_MAX_LIMIT}. Default: ${CONFIG_CONTRACTS_DEFAULT_LIMIT}`,
+		example: 1e3
+	}),
+	chains: csvArray(z$1.string().regex(/^[1-9]\d*$/, { message: "Chain must be a positive integer" }).transform((val) => Number.parseInt(val, 10))).meta({
+		description: "Filter by chain IDs (comma-separated).",
+		example: "1,8453"
+	})
+});
+const GetOffersQueryParams = PaginationQueryParams.omit({ cursor: true }).extend({
+	cursor: z$1.string().optional().meta({
+		description: "Pagination cursor. Use offer hash (0x...) for maker queries, base64url for obligation queries.",
+		example: "eyJzaWRlIjoic2VsbCIsImN1cnJlbnRQcmljZSI6IjEwMDAwMDAwMDAwMDAwMDAwMDAiLCJibG9ja051bWJlciI6MSwiYXNzZXRzIjoiMTAwMDAwMDAwMDAwMDAwMDAwMCIsImhhc2giOiIweGRmZDY4NTllM2UwODJkMTkzODlhMWFlYzFiZGFkN2U4ZDkyZDk2YjFhYTc5NDBkYTkxYTMxMjVkMzFlM2JlNWIiLCJ0b3RhbFJldHVybmVkIjoxMCwibm93IjoxNjAwMDAwMDAwfQ"
+	}),
+	side: z$1.enum(["buy", "sell"]).optional().meta({
+		description: "Side of the offer. Required when using obligation_id.",
+		example: "buy"
+	}),
+	obligation_id: z$1.string().regex(/^0x[a-fA-F0-9]{64}$/, { error: "Obligation id must be a valid 32-byte hex string" }).transform((val) => val.toLowerCase()).optional().meta({
+		description: "Offers obligation id. Required when not using maker.",
+		example: "0x1234567890123456789012345678901234567890123456789012345678901234"
+	}),
+	maker: z$1.string().regex(/^0x[a-fA-F0-9]{40}$/, { error: "Maker must be a valid 20-byte address" }).transform((val) => val.toLowerCase()).optional().meta({
+		description: "Maker address to filter offers by. Alternative to obligation_id + side.",
+		example: "0x7b093658BE7f90B63D7c359e8f408e503c2D9401"
+	})
+}).superRefine((val, ctx) => {
+	const hasObligation = val.obligation_id !== void 0;
+	const hasSide = val.side !== void 0;
+	const hasMaker = val.maker !== void 0;
+	if (hasMaker && (hasObligation || hasSide)) {
+		ctx.addIssue({
+			code: "custom",
+			message: "Cannot use both maker and obligation_id/side parameters"
 		});
-		return failure(err);
+		return;
 	}
-}
-async function getHealthCollectors(query, db, chainRegistry) {
-	const logger = getLogger();
-	try {
-		const parsed = safeParse("get_health_collectors", query);
-		if (!parsed.success) return failure(parsed.error);
-		const snapshot = await create$16({
-			db,
-			chainRegistry
-		}).getSnapshot();
-		if (parsed.data.strict && !snapshot.initialized) return failure(new APIError(STATUS_CODE.INTERNAL_SERVER_ERROR, "Indexer block state is not initialized", "INTERNAL_SERVER_ERROR", toSnakeCase$1({
-			missingChains: snapshot.missingChains,
-			missingCollectors: snapshot.missingCollectors
-		})));
-		const collectors = snapshot.collectors;
-		return success({ data: collectors.map(({ name, chainId, blockNumber, updatedAt, lag, status, initialized }) => toSnakeCase$1({
-			name,
-			chainId,
-			blockNumber,
-			updatedAt,
-			lag,
-			status,
-			initialized
-		})) });
-	} catch (err) {
-		logger.error({
-			err,
-			msg: "Error getting health status for collectors",
-			errorMessage: err instanceof Error ? err.message : String(err),
-			errorStack: err instanceof Error ? err.stack : void 0
+	if (hasMaker) {
+		if (val.cursor !== void 0 && !isValidOfferHashCursor(val.cursor)) ctx.addIssue({
+			code: "custom",
+			path: ["cursor"],
+			message: "Cursor must be a 32-byte hex offer hash when filtering by maker"
 		});
-		return failure(err);
+		return;
+	}
+	if (!hasObligation || !hasSide) ctx.addIssue({
+		code: "custom",
+		message: "Must provide either maker or both obligation_id and side"
+	});
+	if (val.cursor !== void 0 && !isValidBase64urlJson(val.cursor)) ctx.addIssue({
+		code: "custom",
+		path: ["cursor"],
+		message: "Invalid cursor format. Must be a valid base64url-encoded cursor object"
+	});
+}).transform((val) => {
+	if (val.maker && val.cursor) return {
+		...val,
+		cursor: val.cursor.toLowerCase()
+	};
+	return val;
+});
+const GetObligationsQueryParams = z$1.object({
+	...PaginationQueryParams.shape,
+	cursor: z$1.string().optional().meta({
+		description: "Obligation id cursor",
+		example: "0x1234567890123456789012345678901234567890123456789012345678901234"
+	}),
+	chains: csvArray(z$1.string().regex(/^[1-9]\d*$/, { message: "Chain must be a positive integer" }).transform((val) => Number.parseInt(val, 10))).meta({
+		description: "Filter by chain IDs (comma-separated).",
+		example: "1,8453"
+	}),
+	loan_tokens: csvArray(z$1.string().regex(/^0x[a-fA-F0-9]{40}$/, { error: "Loan token must be a valid 20-byte address" }).transform((val) => val.toLowerCase())).meta({
+		description: "Filter by loan token addresses (comma-separated).",
+		example: "0xC9A9C45C0eB717f8b5F193Af6bAa05A1c0Ac5078,0x34Cf890dB685FC536E05652FB41f02090c3fb751"
+	}),
+	collateral_tokens: csvArray(z$1.string().regex(/^0x[a-fA-F0-9]{40}$/, { error: "Collateral token must be a valid 20-byte address" }).transform((val) => val.toLowerCase())).meta({
+		description: "Filter by collateral tokens (comma-separated, matches any collateral).",
+		example: "0x34Cf890dB685FC536E05652FB41f02090c3fb751,0xC9A9C45C0eB717f8b5F193Af6bAa05A1c0Ac5078"
+	}),
+	maturities: csvArray(z$1.string().regex(/^[1-9]\d*$/, { message: "Maturity must be a positive integer" }).transform((val) => Number.parseInt(val, 10))).meta({
+		description: "Filter by exact maturity timestamps (comma-separated, unix seconds).",
+		example: "1761922800,1764524800"
+	})
+});
+const GetObligationParams = z$1.object({ obligation_id: z$1.string({ error: "Obligation id is required and must be a valid 32-byte hex string" }).regex(/^0x[a-fA-F0-9]{64}$/, { error: "Obligation id must be a valid 32-byte hex string" }).transform((val) => val.toLowerCase()).meta({
+	description: "Obligation id",
+	example: "0x1234567890123456789012345678901234567890123456789012345678901234"
+}) });
+/** Validate a book cursor format: {side, lastPrice, offersCursor} */
+function isValidBookCursor(cursorString) {
+	const isNumericString = (value) => typeof value === "string" && /^-?\d+$/.test(value);
+	try {
+		const v = JSON.parse(Buffer.from(cursorString, "base64url").toString("utf8"));
+		return (v?.side === "buy" || v?.side === "sell") && isNumericString(v?.lastPrice) && (v?.offersCursor === null || typeof v?.offersCursor === "string");
+	} catch {
+		return false;
 	}
 }
+const BookPaginationQueryParams = z$1.object({
+	cursor: z$1.string().optional().refine((value) => {
+		if (!value) return true;
+		return isValidBookCursor(value);
+	}, { message: "Invalid cursor format. Must be a valid base64url-encoded book cursor object" }).meta({
+		description: "Pagination cursor in base64url-encoded format for book levels",
+		example: "eyJzaWRlIjoiYnV5IiwibGFzdFJhdGUiOiIxMDAwMDAwMDAwMDAwMDAwMDAwIiwib2ZmZXJzQ3Vyc29yIjpudWxsfQ"
+	}),
+	limit: z$1.string().regex(/^[1-9]\d*$/, { message: "Limit must be a positive integer" }).transform((val) => Number.parseInt(val, 10)).pipe(z$1.number().max(MAX_LIMIT, { message: `Limit cannot exceed ${MAX_LIMIT}` })).optional().default(DEFAULT_LIMIT$4).meta({
+		description: `Limit maximum: ${MAX_LIMIT}. Default: ${DEFAULT_LIMIT$4}`,
+		example: 10
+	})
+});
+const HealthQueryParams = z$1.object({ strict: z$1.enum([
+	"true",
+	"false",
+	"1",
+	"0"
+]).transform((value) => value === "true" || value === "1").optional().meta({
+	description: "Enable strict mode to fail health checks when initialization is incomplete.",
+	example: "true"
+}) });
+const GetBookParams = z$1.object({
+	...BookPaginationQueryParams.shape,
+	obligation_id: z$1.string({ error: "Obligation id is required and must be a valid 32-byte hex string" }).regex(/^0x[a-fA-F0-9]{64}$/, { error: "Obligation id must be a valid 32-byte hex string" }).transform((val) => val.toLowerCase()).meta({
+		description: "Obligation id",
+		example: "0x1234567890123456789012345678901234567890123456789012345678901234"
+	}),
+	side: z$1.enum(["buy", "sell"]).meta({
+		description: "Side of the book (buy or sell).",
+		example: "buy"
+	})
+});
+const ValidateOffersBody = z$1.object({ offers: z$1.array(z$1.unknown()).min(1, { message: "'offers' must contain at least 1 offer" }) }).strict();
+const GetUserPositionsParams = z$1.object({
+	...PaginationQueryParams.shape,
+	user_address: z$1.string().regex(/^0x[a-fA-F0-9]{40}$/, { error: "User address must be a valid 20-byte address" }).transform((val) => val.toLowerCase()).meta({
+		description: "User address to get positions for",
+		example: "0x7b093658BE7f90B63D7c359e8f408e503c2D9401"
+	})
+});
+const schemas = {
+	get_health: HealthQueryParams,
+	get_health_collectors: HealthQueryParams,
+	get_health_chains: HealthQueryParams,
+	get_config_contracts: GetConfigContractsQueryParams,
+	get_config_rules: GetConfigRulesQueryParams,
+	get_offers: GetOffersQueryParams,
+	get_obligations: GetObligationsQueryParams,
+	get_obligation: GetObligationParams,
+	get_book: GetBookParams,
+	validate_offers: ValidateOffersBody,
+	get_user_positions: GetUserPositionsParams
+};
+function parse(action, query) {
+	return schemas[action].parse(query);
+}
+function safeParse(action, query, error) {
+	return schemas[action].safeParse(query, { error });
+}
 
 //#endregion
-//#region src/api/Controllers/getObligation.ts
-async function getObligation(params, db) {
+//#region src/api/Controllers/getBook.ts
+async function getBook(params, db) {
 	const logger = getLogger();
-	const result = safeParse("get_obligation", params, (issue) => issue.message);
+	const result = safeParse("get_book", params, (issue) => issue.message);
 	if (!result.success) return failure(result.error);
 	const query = result.data;
 	try {
-		const { obligations } = await db.offers.getObligations({ ids: [query.obligation_id] });
-		if (obligations.length === 0) return failure(new NotFoundError("Obligation not found"));
-		const obligation = obligations[0];
-		const [quote] = await db.offers.getQuotes({ obligationIds: [id(obligation)] });
+		const { levels, nextCursor } = await db.book.get({
+			side: query.side,
+			obligationId: query.obligation_id,
+			cursor: query.cursor,
+			limit: query.limit
+		});
 		return success({
-			data: from$4(obligation, quote ?? {
-				obligationId: id(obligation),
-				ask: { price: 0n },
-				bid: { price: 0n }
-			}),
-			cursor: null
+			data: levels.map(from$5),
+			cursor: nextCursor
 		});
 	} catch (err) {
 		logger.error({
 			err,
-			msg: "Error get obligation",
+			msg: "Error get book",
 			errorMessage: err instanceof Error ? err.message : String(err),
 			errorStack: err instanceof Error ? err.stack : void 0
 		});
@@ -7043,463 +6815,649 @@ async function getObligation(params, db) {
 }
 
 //#endregion
-//#region src/api/Controllers/getObligations.ts
-async function getObligations$1(queryParameters, db) {
-	const logger = getLogger();
-	const result = safeParse("get_obligations", queryParameters, (issue) => issue.message);
-	if (!result.success) return failure(result.error);
-	const query = result.data;
-	try {
-		const chainIds = query.chains?.length ? query.chains : void 0;
-		const loanTokens = query.loan_tokens?.length ? query.loan_tokens : void 0;
-		const collateralTokens = query.collateral_tokens?.length ? query.collateral_tokens : void 0;
-		const maturities = query.maturities?.length ? query.maturities : void 0;
-		const { obligations, nextCursor } = await db.offers.getObligations({
-			cursor: query.cursor,
-			limit: query.limit,
-			chainId: chainIds,
-			loanToken: loanTokens,
-			collateralToken: collateralTokens,
-			maturity: maturities
-		});
-		const quotes = await db.offers.getQuotes({ obligationIds: obligations.map((o) => id(o)) });
-		return success({
-			data: obligations.map((o) => from$4(o, quotes.find((q) => q.obligationId === id(o)) ?? {
-				obligationId: id(o),
-				ask: { price: 0n },
-				bid: { price: 0n }
-			})),
-			cursor: nextCursor ?? null
-		});
+//#region src/api/Controllers/getConfigContracts.ts
+const CONFIG_CONTRACT_NAMES = [
+	"mempool",
+	"multicall",
+	"v2"
+];
+/**
+* Returns contract addresses used by indexers (mempool, v2) plus multicall per chain.
+* @param query - Raw query parameters containing optional chain filters.
+* @param chainRegistry - The chain registry instance. {@link ChainRegistry.ChainRegistry}
+* @returns The indexer contract configuration. {@link ApiPayload.Payload<ConfigContract[]>}
+*/
+async function getConfigContracts(query, chainRegistry) {
+	const parsed = safeParse("get_config_contracts", query ?? {});
+	if (!parsed.success) return failure(parsed.error);
+	const { chains: chainsFilter, cursor, limit } = parsed.data;
+	const chainFilter = chainsFilter?.length ? new Set(chainsFilter) : null;
+	const contracts = [];
+	const seenAddresses = /* @__PURE__ */ new Set();
+	for (const chain of chainRegistry.list()) {
+		if (chainFilter && !chainFilter.has(chain.id)) continue;
+		const mempool = chain.custom?.mempool?.address;
+		if (!mempool) return failure(new InternalServerError(`Missing mempool address for chain ${chain.id}.`));
+		const multicall = chain.contracts?.multicall3?.address;
+		if (!multicall) return failure(new InternalServerError(`Missing multicall3 address for chain ${chain.id}.`));
+		const v2 = chain.custom?.morpho?.address;
+		if (!v2) return failure(new InternalServerError(`Missing morpho address for chain ${chain.id}.`));
+		const chainContracts = [
+			{
+				chain_id: chain.id,
+				name: "mempool",
+				address: mempool
+			},
+			{
+				chain_id: chain.id,
+				name: "multicall",
+				address: multicall
+			},
+			{
+				chain_id: chain.id,
+				name: "v2",
+				address: v2
+			}
+		];
+		for (const contract of chainContracts) {
+			const cursorKey = `${contract.chain_id}:${contract.address.toLowerCase()}`;
+			if (seenAddresses.has(cursorKey)) return failure(new InternalServerError(`Duplicate contract address ${contract.address} for chain ${chain.id}.`));
+			seenAddresses.add(cursorKey);
+			contracts.push(contract);
+		}
+	}
+	contracts.sort((a, b) => {
+		if (a.chain_id !== b.chain_id) return a.chain_id - b.chain_id;
+		const addressCompare = a.address.toLowerCase().localeCompare(b.address.toLowerCase());
+		if (addressCompare !== 0) return addressCompare;
+		return a.name.localeCompare(b.name);
+	});
+	let cursorContract = null;
+	if (cursor) try {
+		cursorContract = parseCursor$1(cursor);
 	} catch (err) {
-		logger.error({
-			err,
-			msg: "Error get obligations",
-			errorMessage: err instanceof Error ? err.message : String(err),
-			errorStack: err instanceof Error ? err.stack : void 0
-		});
 		return failure(err);
 	}
+	const startIndex = cursorContract ? findStartIndex$1(contracts, cursorContract) : 0;
+	const page = contracts.slice(startIndex, startIndex + limit);
+	const nextCursor = startIndex + limit < contracts.length && page.length > 0 ? formatCursor$1(page.at(-1)) : null;
+	return success({
+		data: page,
+		cursor: nextCursor
+	});
 }
-
-//#endregion
-//#region src/database/constants.ts
-/**
-* Default batch size for bulk database inserts.
-*
-* PostgreSQL limits a single query to at most 65,535 parameters
-* (e.g. $1, $2, ...). In bulk inserts, each row consumes one
-* parameter per column, so inserting too many rows at once can
-* exceed this limit.
-*
-* Our largest batched insert is into the `offers` table with 15 columns.
-* 15 cols × 4,000 rows = 60,000 parameters, safely under 65,535.
-*/
-const DEFAULT_BATCH_SIZE$1 = 4e3;
-
-//#endregion
-//#region src/database/drizzle/VERSION.ts
-const VERSION = "router_v1.6";
-
-//#endregion
-//#region src/database/drizzle/schema.ts
-var schema_exports = /* @__PURE__ */ __exportAll({
-	PositionTypes: () => PositionTypes,
-	StatusCode: () => StatusCode,
-	TABLE_NAMES: () => TABLE_NAMES,
-	VERSIONED_TABLE_NAMES: () => VERSIONED_TABLE_NAMES,
-	callbacks: () => callbacks,
-	chains: () => chains$1,
-	collectors: () => collectors,
-	consumedEvents: () => consumedEvents,
-	groups: () => groups,
-	lots: () => lots,
-	merklePaths: () => merklePaths,
-	obligationCollateralsV2: () => obligationCollateralsV2,
-	obligations: () => obligations,
-	offers: () => offers,
-	offersCallbacks: () => offersCallbacks,
-	offsets: () => offsets,
-	oracles: () => oracles,
-	positionTypes: () => positionTypes,
-	positions: () => positions,
-	status: () => status,
-	transfers: () => transfers,
-	trees: () => trees,
-	validations: () => validations
-});
-const s = pgSchema(VERSION);
-var EnumTableName = /* @__PURE__ */ function(EnumTableName) {
-	EnumTableName["OBLIGATIONS"] = "obligations";
-	EnumTableName["GROUPS"] = "groups";
-	EnumTableName["CONSUMED_EVENTS"] = "consumed_events";
-	EnumTableName["OBLIGATION_COLLATERALS_V2"] = "obligation_collaterals_v2";
-	EnumTableName["ORACLES"] = "oracles";
-	EnumTableName["OFFERS"] = "offers";
-	EnumTableName["OFFERS_CALLBACKS"] = "offers_callbacks";
-	EnumTableName["CALLBACKS"] = "callbacks";
-	EnumTableName["POSITIONS"] = "positions";
-	EnumTableName["TRANSFERS"] = "transfers";
-	EnumTableName["VALIDATIONS"] = "validations";
-	EnumTableName["COLLECTORS"] = "collectors";
-	EnumTableName["CHAINS"] = "chains";
-	EnumTableName["LOTS"] = "lots";
-	EnumTableName["OFFSETS"] = "offsets";
-	EnumTableName["TREES"] = "trees";
-	EnumTableName["MERKLE_PATHS"] = "merkle_paths";
-	return EnumTableName;
-}(EnumTableName || {});
-const TABLE_NAMES = Object.values(EnumTableName);
-const VERSIONED_TABLE_NAMES = TABLE_NAMES.map((table) => `"${VERSION}"."${table}"`);
-const obligations = s.table(EnumTableName.OBLIGATIONS, {
-	obligationId: varchar("obligation_id", { length: 66 }).primaryKey(),
-	chainId: bigint("chain_id", { mode: "number" }).$type().notNull(),
-	loanToken: varchar("loan_token", { length: 42 }).notNull(),
-	maturity: integer("maturity").notNull()
-});
-const groups = s.table(EnumTableName.GROUPS, {
-	chainId: bigint("chain_id", { mode: "number" }).$type().notNull(),
-	maker: varchar("maker", { length: 42 }).notNull(),
-	group: varchar("group", { length: 66 }).notNull(),
-	consumed: numeric("consumed", {
-		precision: 78,
-		scale: 0
-	}).notNull(),
-	blockNumber: bigint("block_number", { mode: "number" }).notNull(),
-	updatedAt: timestamp("updated_at").defaultNow().notNull()
-}, (table) => [primaryKey({
-	columns: [
-		table.chainId,
-		table.maker,
-		table.group
-	],
-	name: "groups_pk"
-}), index("groups_chain_id_maker_group_consumed_idx").on(table.chainId, table.maker, table.group, table.consumed)]);
-const consumedEvents = s.table(EnumTableName.CONSUMED_EVENTS, {
-	eventId: varchar("event_id", { length: 128 }).primaryKey(),
-	chainId: bigint("chain_id", { mode: "number" }).$type().notNull(),
-	maker: varchar("maker", { length: 42 }).notNull(),
-	group: varchar("group", { length: 66 }).notNull(),
-	amount: numeric("amount", {
-		precision: 78,
-		scale: 0
-	}).notNull(),
-	blockNumber: bigint("block_number", { mode: "number" }).notNull(),
-	createdAt: timestamp("created_at").defaultNow().notNull()
-}, (t) => [
-	foreignKey({
-		columns: [
-			t.chainId,
-			t.maker,
-			t.group
-		],
-		foreignColumns: [
-			groups.chainId,
-			groups.maker,
-			groups.group
-		],
-		name: "consumed_events_groups_fk"
-	}).onDelete("cascade"),
-	index("consumed_events_group_idx").on(t.chainId, t.maker, t.group),
-	index("consumed_events_block_number_idx").on(t.blockNumber)
-]);
-const obligationCollateralsV2 = s.table(EnumTableName.OBLIGATION_COLLATERALS_V2, {
-	obligationId: varchar("obligation_id", { length: 66 }).notNull().references(() => obligations.obligationId, { onDelete: "cascade" }),
-	asset: varchar("asset", { length: 42 }).notNull(),
-	oracleChainId: bigint("oracle_chain_id", { mode: "number" }).$type().notNull(),
-	oracleAddress: varchar("oracle_address", { length: 42 }).notNull(),
-	lltv: bigint("lltv", { mode: "bigint" }).notNull(),
-	updatedAt: timestamp("updated_at").defaultNow().notNull()
-}, (table) => [
-	primaryKey({
-		columns: [table.obligationId, table.asset],
-		name: "obligation_collaterals_v2_pk"
-	}),
-	foreignKey({
-		columns: [table.oracleChainId, table.oracleAddress],
-		foreignColumns: [oracles.chainId, oracles.address],
-		name: "obligation_collaterals_v2_oracles_fk"
-	}),
-	index("obligation_collaterals_v2_obligation_id_idx").on(table.obligationId),
-	index("obligation_collaterals_v2_oracle_fk_idx").on(table.oracleChainId, table.oracleAddress)
-]);
-const oracles = s.table(EnumTableName.ORACLES, {
-	chainId: bigint("chain_id", { mode: "number" }).$type().notNull(),
-	address: varchar("address", { length: 42 }).notNull(),
-	price: numeric("price", {
-		precision: 78,
-		scale: 0
-	}),
-	blockNumber: bigint("block_number", { mode: "number" }).notNull(),
-	updatedAt: timestamp("updated_at").defaultNow().notNull()
-}, (table) => [primaryKey({
-	columns: [table.chainId, table.address],
-	name: "oracles_pk"
-})]);
-const offers = s.table(EnumTableName.OFFERS, {
-	hash: varchar("hash", { length: 66 }).primaryKey(),
-	obligationId: varchar("obligation_id", { length: 66 }).notNull().references(() => obligations.obligationId, { onDelete: "cascade" }),
-	assets: numeric("assets", {
-		precision: 78,
-		scale: 0
-	}).notNull(),
-	obligationUnits: numeric("obligation_units", {
-		precision: 78,
-		scale: 0
-	}).notNull().default("0"),
-	obligationShares: numeric("obligation_shares", {
-		precision: 78,
-		scale: 0
-	}).notNull().default("0"),
-	price: numeric("price", {
-		precision: 78,
-		scale: 0
-	}).notNull(),
-	maturity: integer("maturity").notNull(),
-	expiry: integer("expiry").notNull(),
-	start: integer("start").notNull(),
-	groupChainId: bigint("group_chain_id", { mode: "number" }).$type().notNull(),
-	groupMaker: varchar("group_maker", { length: 42 }).notNull(),
-	group: varchar("group_group", { length: 66 }).notNull(),
-	session: varchar("session", { length: 66 }).notNull(),
-	buy: boolean("buy").notNull(),
-	callbackAddress: varchar("callback_address", { length: 42 }).notNull(),
-	callbackData: text("callback_data").notNull(),
-	blockNumber: bigint("block_number", { mode: "number" }).notNull(),
-	updatedAt: timestamp("updated_at").defaultNow().notNull()
-}, (table) => [
-	foreignKey({
-		columns: [
-			table.groupChainId,
-			table.groupMaker,
-			table.group
-		],
-		foreignColumns: [
-			groups.chainId,
-			groups.maker,
-			groups.group
-		],
-		name: "offers_groups_fk"
-	}).onDelete("cascade"),
-	index("offers_group_fk_idx").on(table.groupChainId, table.groupMaker, table.group),
-	index("offers_group_and_hash_idx").on(table.groupChainId, table.groupMaker, table.group, table.hash),
-	index("offers_obligation_id_side_idx").on(table.obligationId, table.buy)
-]);
-const offersCallbacks = s.table(EnumTableName.OFFERS_CALLBACKS, {
-	offerHash: varchar("offer_hash", { length: 66 }).notNull().references(() => offers.hash, { onDelete: "cascade" }),
-	callbackId: varchar("callback_id", { length: 66 })
-}, (table) => [primaryKey({
-	columns: [table.offerHash, table.callbackId],
-	name: "offers_callbacks_pk"
-})]);
-const callbacks = s.table(EnumTableName.CALLBACKS, {
-	id: varchar("id", { length: 66 }).primaryKey(),
-	positionChainId: bigint("position_chain_id", { mode: "number" }).$type().notNull(),
-	positionContract: varchar("position_contract", { length: 42 }).notNull(),
-	positionUser: varchar("position_user", { length: 42 }).notNull(),
-	amount: numeric("amount", {
-		precision: 78,
-		scale: 0
-	})
-}, (table) => [foreignKey({
-	columns: [
-		table.positionChainId,
-		table.positionContract,
-		table.positionUser
+function parseCursor$1(cursor) {
+	const [chain, address] = cursor.split(":", 2);
+	if (!chain || !address) throw new BadRequestError("Cursor must be in the format chain_id:0x...");
+	return {
+		chain_id: Number.parseInt(chain, 10),
+		address: address.toLowerCase()
+	};
+}
+function formatCursor$1(contract) {
+	return `${contract.chain_id}:${contract.address.toLowerCase()}`;
+}
+function findStartIndex$1(contracts, cursor) {
+	let low = 0;
+	let high = contracts.length;
+	while (low < high) {
+		const mid = Math.floor((low + high) / 2);
+		const current = contracts[mid];
+		if (compareContract(current, cursor) <= 0) low = mid + 1;
+		else high = mid;
+	}
+	return low;
+}
+function compareContract(contract, cursor) {
+	if (contract.chain_id !== cursor.chain_id) return contract.chain_id - cursor.chain_id;
+	return contract.address.toLowerCase().localeCompare(cursor.address.toLowerCase());
+}
+
+//#endregion
+//#region src/gatekeeper/GateConfig.ts
+const assets = {
+	[ChainId.ETHEREUM.toString()]: [
+		"0xA0b86991c6218b36c1d19D4a2e9Eb0cE3606eB48",
+		"0x6B175474E89094C44Da98b954EedeAC495271d0F",
+		"0xC02aaA39b223FE8D0A0e5C4F27eAD9083C756Cc2",
+		"0x2260FAC5E5542a773Aa44fBCfeDf7C193bc2C599",
+		"0x1aBaEA1f7C830bD89Acc67eC4af516284b1bC33c",
+		"0x7f39C581F595B53c5cb19bD0b3f8dA6c935E2Ca0"
 	],
-	foreignColumns: [
-		positions.chainId,
-		positions.contract,
-		positions.user
+	[ChainId.BASE.toString()]: [
+		"0x833589fCD6eDb6E08f4c7C32D4f71b54bdA02913",
+		"0x50c5725949A6F0c72E6C4a641F24049A917DB0Cb",
+		"0x4200000000000000000000000000000000000006",
+		"0x2260FAC5E5542a773Aa44fBCfeDf7C193bc2C599",
+		"0xcbB7C0000aB88B473b1f5aFd9ef808440eed33Bf",
+		"0xc1CBa3fCea344f92D9239c08C0568f6F2F0ee452",
+		"0x60a3E35Cc302bFA44Cb288Bc5a4F316Fdb1adb42"
 	],
-	name: "callbacks_positions_fk"
-}).onDelete("cascade")]);
-const lots = s.table(EnumTableName.LOTS, {
-	chainId: bigint("chain_id", { mode: "number" }).$type().notNull(),
-	user: varchar("user", { length: 42 }).notNull(),
-	contract: varchar("contract", { length: 42 }).notNull(),
-	group: varchar("group", { length: 66 }).notNull(),
-	lower: numeric("lower", {
-		precision: 78,
-		scale: 0
-	}).notNull(),
-	upper: numeric("upper", {
-		precision: 78,
-		scale: 0
-	}).notNull()
-}, (table) => [
-	primaryKey({
-		columns: [
-			table.chainId,
-			table.user,
-			table.contract,
-			table.group
-		],
-		name: "lots_pk"
-	}),
-	foreignKey({
-		columns: [
-			table.chainId,
-			table.contract,
-			table.user
-		],
-		foreignColumns: [
-			positions.chainId,
-			positions.contract,
-			positions.user
-		],
-		name: "lots_positions_fk"
-	}).onDelete("cascade"),
-	foreignKey({
-		columns: [
-			table.chainId,
-			table.user,
-			table.group
-		],
-		foreignColumns: [
-			groups.chainId,
-			groups.maker,
-			groups.group
-		],
-		name: "lots_groups_fk"
-	}).onDelete("cascade")
-]);
-const offsets = s.table(EnumTableName.OFFSETS, {
-	chainId: bigint("chain_id", { mode: "number" }).$type().notNull(),
-	user: varchar("user", { length: 42 }).notNull(),
-	contract: varchar("contract", { length: 42 }).notNull(),
-	group: varchar("group", { length: 66 }).notNull(),
-	value: numeric("value", {
-		precision: 78,
-		scale: 0
-	}).notNull()
-}, (table) => [primaryKey({
-	columns: [
-		table.chainId,
-		table.user,
-		table.contract,
-		table.group
+	[ChainId["ETHEREUM-VIRTUAL-TESTNET"].toString()]: [
+		"0xA0b86991c6218b36c1d19D4a2e9Eb0cE3606eB48",
+		"0x6B175474E89094C44Da98b954EedeAC495271d0F",
+		"0xC02aaA39b223FE8D0A0e5C4F27eAD9083C756Cc2",
+		"0x2260FAC5E5542a773Aa44fBCfeDf7C193bc2C599",
+		"0xce79ddb3152d52ff8fe65a4c7e058b035fcb560a"
 	],
-	name: "offsets_pk"
-}), foreignKey({
-	columns: [
-		table.chainId,
-		table.contract,
-		table.user
+	[ChainId.ANVIL.toString()]: [
+		"0xA0b86991c6218b36c1d19D4a2e9Eb0cE3606eB48",
+		"0x6B175474E89094C44Da98b954EedeAC495271d0F",
+		"0xC02aaA39b223FE8D0A0e5C4F27eAD9083C756Cc2",
+		"0x2260FAC5E5542a773Aa44fBCfeDf7C193bc2C599"
+	]
+};
+const oracles = {
+	[ChainId.ETHEREUM.toString()]: [
+		"0xDddd770BADd886dF3864029e4B377B5F6a2B6b83",
+		"0x9CB3f4276bcD149b3668e1a645a964bC12877b89",
+		"0x48F7E36EB6B826B2dF4B2E630B62Cd25e89E40e2",
+		"0x6Eb9F4128CeBc8B885A4d8562Db1Addf097f7348",
+		"0xbD60A6770b27E084E8617335ddE769241B0e71D8",
+		"0xAe12416c1F21B0698c27fe042D9309C83baC6597"
 	],
-	foreignColumns: [
-		positions.chainId,
-		positions.contract,
-		positions.user
+	[ChainId.BASE.toString()]: [
+		"0xD09048c8B568Dbf5f189302beA26c9edABFC4858",
+		"0xFEa2D58cEfCb9fcb597723c6bAE66fFE4193aFE4",
+		"0x05D2618404668D725B66c0f32B39e4EC15B393dC",
+		"0xE1bb8E5b4930eC9FeC7f7943FCF6227649F14B37",
+		"0x663BECd10daE6C4A3Dcd89F1d76c1174199639B9",
+		"0x10b95702a0ce895972C91e432C4f7E19811D320E",
+		"0x8C87DbD7A0c647A4291592Bc2994dbF95880fE2F",
+		"0x4A11590e5326138B514E08A9B52202D42077Ca65",
+		"0xa54122f0E0766258377Ffe732e454A3248f454F4"
 	],
-	name: "offsets_positions_fk"
-}).onDelete("cascade")]);
-const PositionTypes = s.enum("position_type", Object.values(Type));
-const positionTypes = s.table("position_types", {
-	id: serial("id").primaryKey(),
-	type: PositionTypes("type").notNull()
-});
-const positions = s.table(EnumTableName.POSITIONS, {
-	chainId: bigint("chain_id", { mode: "number" }).$type().notNull(),
-	contract: varchar("contract", { length: 42 }).notNull(),
-	user: varchar("user", { length: 42 }).notNull(),
-	positionTypeId: integer("position_type_id").notNull().references(() => positionTypes.id, { onDelete: "no action" }),
-	balance: numeric("balance", {
-		precision: 78,
-		scale: 0
-	}),
-	asset: varchar("asset", { length: 42 }),
-	blockNumber: bigint("block_number", { mode: "number" }).notNull(),
-	updatedAt: timestamp("updated_at").defaultNow().notNull()
-}, (table) => [primaryKey({
-	columns: [
-		table.chainId,
-		table.contract,
-		table.user
+	[ChainId["ETHEREUM-VIRTUAL-TESTNET"].toString()]: [
+		"0xDddd770BADd886dF3864029e4B377B5F6a2B6b83",
+		"0x9CB3f4276bcD149b3668e1a645a964bC12877b89",
+		"0x48F7E36EB6B826B2dF4B2E630B62Cd25e89E40e2",
+		"0x6Eb9F4128CeBc8B885A4d8562Db1Addf097f7348",
+		"0xbD60A6770b27E084E8617335ddE769241B0e71D8",
+		"0xAe12416c1F21B0698c27fe042D9309C83baC6597"
 	],
-	name: "positions_pk"
-})]);
-const transfers = s.table(EnumTableName.TRANSFERS, {
-	eventId: varchar("event_id", { length: 128 }).primaryKey(),
-	chainId: bigint("chain_id", { mode: "number" }).$type().notNull(),
-	contract: varchar("contract", { length: 42 }).notNull(),
-	from: varchar("from", { length: 42 }).notNull(),
-	to: varchar("to", { length: 42 }).notNull(),
-	value: numeric("value", {
-		precision: 78,
-		scale: 0
-	}).notNull(),
-	blockNumber: bigint("block_number", { mode: "number" }).notNull(),
-	createdAt: timestamp("created_at").defaultNow().notNull()
-}, (table) => [
-	foreignKey({
-		columns: [
-			table.chainId,
-			table.contract,
-			table.from
-		],
-		foreignColumns: [
-			positions.chainId,
-			positions.contract,
-			positions.user
-		],
-		name: "transfers_positions_from_fk"
-	}).onDelete("cascade"),
-	foreignKey({
-		columns: [
-			table.chainId,
-			table.contract,
-			table.to
-		],
-		foreignColumns: [
-			positions.chainId,
-			positions.contract,
-			positions.user
-		],
-		name: "transfers_positions_to_fk"
-	}).onDelete("cascade"),
-	index("transfers_chain_contract_user_idx").on(table.chainId, table.contract, table.from, table.to, table.blockNumber)
-]);
-const StatusCode = s.enum("status_code", Object.values(Status));
-const status = s.table("status", {
-	id: serial("id").primaryKey(),
-	code: StatusCode("code").unique()
-});
-const validations = s.table("validations", {
-	offerHash: varchar("offer_hash", { length: 66 }).primaryKey().references(() => offers.hash, { onDelete: "cascade" }),
-	statusId: integer("status_id").notNull().references(() => status.id, { onDelete: "no action" }),
-	updatedAt: timestamp("updated_at").defaultNow().notNull()
-});
-const collectors = s.table(EnumTableName.COLLECTORS, {
-	chainId: bigint("chain_id", { mode: "number" }).$type().notNull().references(() => chains$1.chainId, { onDelete: "no action" }),
-	name: text("name").$type().notNull(),
-	blockNumber: bigint("block_number", { mode: "number" }).notNull(),
-	epoch: numeric("epoch", {
-		precision: 78,
-		scale: 0
-	}).default("0").notNull(),
-	updatedAt: timestamp("updated_at").defaultNow().notNull()
-}, (table) => [uniqueIndex("collectors_chain_name_idx").on(table.chainId, table.name)]);
-const chains$1 = s.table(EnumTableName.CHAINS, {
-	chainId: bigint("chain_id", { mode: "number" }).$type().notNull(),
-	blockNumber: bigint("block_number", { mode: "number" }).notNull(),
-	epoch: numeric("epoch", {
-		precision: 78,
-		scale: 0
-	}).default("0").notNull(),
-	updatedAt: timestamp("updated_at").defaultNow().notNull()
-}, (table) => [uniqueIndex("chains_chain_id_idx").on(table.chainId)]);
-const trees = s.table(EnumTableName.TREES, {
-	root: varchar("root", { length: 66 }).primaryKey(),
-	rootSignature: varchar("root_signature", { length: 132 }).notNull(),
-	createdAt: timestamp("created_at").defaultNow().notNull()
-});
-const merklePaths = s.table(EnumTableName.MERKLE_PATHS, {
-	offerHash: varchar("offer_hash", { length: 66 }).primaryKey().references(() => offers.hash, { onDelete: "cascade" }),
-	treeRoot: varchar("tree_root", { length: 66 }).notNull().references(() => trees.root, { onDelete: "cascade" }),
-	proofNodes: text("proof_nodes").notNull(),
-	createdAt: timestamp("created_at").defaultNow().notNull()
-}, (table) => [index("merkle_paths_tree_root_idx").on(table.treeRoot)]);
+	[ChainId.ANVIL.toString()]: [
+		"0xDddd770BADd886dF3864029e4B377B5F6a2B6b83",
+		"0x9CB3f4276bcD149b3668e1a645a964bC12877b89",
+		"0x48F7E36EB6B826B2dF4B2E630B62Cd25e89E40e2",
+		"0x6Eb9F4128CeBc8B885A4d8562Db1Addf097f7348",
+		"0xbD60A6770b27E084E8617335ddE769241B0e71D8",
+		"0xAe12416c1F21B0698c27fe042D9309C83baC6597"
+	]
+};
+const configs = {
+	ethereum: {
+		callbacks: [{ type: Type$1.BuyWithEmptyCallback }, { type: Type$1.SellWithEmptyCallback }],
+		maturities: [MaturityType.EndOfMonth, MaturityType.EndOfNextMonth]
+	},
+	base: {
+		callbacks: [{ type: Type$1.BuyWithEmptyCallback }, { type: Type$1.SellWithEmptyCallback }],
+		maturities: [MaturityType.EndOfMonth, MaturityType.EndOfNextMonth]
+	},
+	"ethereum-virtual-testnet": {
+		callbacks: [{ type: Type$1.BuyWithEmptyCallback }, { type: Type$1.SellWithEmptyCallback }],
+		maturities: [MaturityType.EndOfMonth, MaturityType.EndOfNextMonth]
+	},
+	anvil: {
+		callbacks: [{ type: Type$1.BuyWithEmptyCallback }, { type: Type$1.SellWithEmptyCallback }],
+		maturities: [MaturityType.EndOfMonth, MaturityType.EndOfNextMonth]
+	}
+};
+
+//#endregion
+//#region src/gatekeeper/ConfigRules.ts
+/**
+* Build the configured rules (maturities + callback addresses + loan tokens + oracles) for the provided chains.
+* @param chains - Chains to include in the configured rules.
+* @returns Sorted list of config rules.
+*/
+function buildConfigRules(chains) {
+	const rules = [];
+	for (const chain of chains) {
+		const maturities = configs[chain.name].maturities ?? [];
+		for (const maturityName of maturities) rules.push({
+			type: "maturity",
+			chain_id: chain.id,
+			name: maturityName,
+			timestamp: from$16(maturityName)
+		});
+		const loanTokens = assets[chain.id.toString()] ?? [];
+		for (const address of loanTokens) rules.push({
+			type: "loan_token",
+			chain_id: chain.id,
+			address: normalizeAddress(address)
+		});
+		const oracles$2 = oracles[chain.id.toString()] ?? [];
+		for (const address of oracles$2) rules.push({
+			type: "oracle",
+			chain_id: chain.id,
+			address: normalizeAddress(address)
+		});
+	}
+	rules.sort(compareConfigRules);
+	return rules;
+}
+/**
+* Compute a stable checksum for the provided configured rules.
+* @param rules - Configured rules to checksum.
+* @returns MD5 checksum.
+*/
+function buildConfigRulesChecksum(rules) {
+	const hash = createHash("md5");
+	const orderedRules = [...rules].sort(compareConfigRules);
+	for (const rule of orderedRules) {
+		if (rule.type === "maturity") {
+			hash.update(`maturity:${rule.chain_id}:${rule.name}:${rule.timestamp}\n`);
+			continue;
+		}
+		if (rule.type === "callback") {
+			hash.update(`callback:${rule.chain_id}:${rule.callback_type}:${rule.address}\n`);
+			continue;
+		}
+		if (rule.type === "oracle") {
+			hash.update(`oracle:${rule.chain_id}:${rule.address}\n`);
+			continue;
+		}
+		hash.update(`loan_token:${rule.chain_id}:${rule.address}\n`);
+	}
+	return hash.digest("hex");
+}
+function normalizeAddress(address) {
+	return address.toLowerCase();
+}
+function compareConfigRules(left, right) {
+	if (left.chain_id !== right.chain_id) return left.chain_id - right.chain_id;
+	if (left.type !== right.type) return left.type.localeCompare(right.type);
+	if (left.type === "maturity" && right.type === "maturity") return left.timestamp - right.timestamp;
+	if (left.type === "callback" && right.type === "callback") {
+		if (left.callback_type !== right.callback_type) return left.callback_type.localeCompare(right.callback_type);
+		return left.address.localeCompare(right.address);
+	}
+	if (left.type === "loan_token" && right.type === "loan_token") return left.address.localeCompare(right.address);
+	if (left.type === "oracle" && right.type === "oracle") return left.address.localeCompare(right.address);
+	return 0;
+}
+
+//#endregion
+//#region src/api/Controllers/getConfigRules.ts
+/**
+* Returns configured rules for the configured chains.
+* @param query - Raw query parameters containing filters/cursor/limit.
+* @param chains - Chains to include in the configured rules.
+* @returns Config rules response payload. {@link ApiPayload.Payload}
+*/
+async function getConfigRules(query, chains) {
+	const parsed = safeParse("get_config_rules", query ?? {});
+	if (!parsed.success) return failure(parsed.error);
+	const { cursor, limit, types, chains: chainIds } = parsed.data;
+	const typeFilter = types?.length ? new Set(types) : null;
+	const chainFilter = chainIds?.length ? new Set(chainIds) : null;
+	const filteredRules = buildConfigRules(chains).filter((rule) => {
+		if (chainFilter && !chainFilter.has(rule.chain_id)) return false;
+		if (typeFilter && !typeFilter.has(rule.type)) return false;
+		return true;
+	});
+	const checksum = buildConfigRulesChecksum(filteredRules);
+	let cursorRule = null;
+	if (cursor) try {
+		cursorRule = parseCursor(cursor);
+	} catch (err) {
+		return failure(err);
+	}
+	if (cursorRule && typeFilter && !typeFilter.has(cursorRule.type)) return failure(new BadRequestError("Cursor type must match requested rule types"));
+	if (cursorRule && chainFilter && !chainFilter.has(cursorRule.chain_id)) return failure(new BadRequestError("Cursor chain_id must match requested chains"));
+	const startIndex = cursorRule ? findStartIndex(filteredRules, cursorRule) : 0;
+	const page = filteredRules.slice(startIndex, startIndex + limit);
+	const nextCursor = startIndex + limit < filteredRules.length && page.length > 0 ? formatCursor(page.at(-1)) : null;
+	const response = success({
+		data: page,
+		cursor: nextCursor
+	});
+	response.body.meta.checksum = checksum;
+	return response;
+}
+function formatCursor(rule) {
+	if (rule.type === "maturity") return `maturity:${rule.chain_id}:${rule.timestamp}:${rule.name}`;
+	if (rule.type === "callback") return `callback:${rule.chain_id}:${rule.callback_type}:${rule.address.toLowerCase()}`;
+	if (rule.type === "oracle") return `oracle:${rule.chain_id}:${rule.address.toLowerCase()}`;
+	return `loan_token:${rule.chain_id}:${rule.address.toLowerCase()}`;
+}
+function parseCursor(cursor) {
+	const [type, chain, ...rest] = cursor.split(":");
+	if (!type || !chain || rest.length === 0) throw new BadRequestError("Cursor must be in the format type:chain_id:<value>");
+	if (!isConfigRuleType(type)) throw new BadRequestError("Cursor has an invalid rule type");
+	const chain_id = Number.parseInt(chain, 10);
+	if (!Number.isFinite(chain_id)) throw new BadRequestError("Cursor has an invalid chain_id");
+	if (type === "maturity") {
+		const timestampValue = Number.parseInt(rest[0] ?? "", 10);
+		const nameValue = rest.slice(1).join(":");
+		if (!Number.isFinite(timestampValue) || nameValue.length === 0) throw new BadRequestError("Cursor must be in the format maturity:chain_id:timestamp:name");
+		if (!isMaturityType(nameValue)) throw new BadRequestError("Cursor has an invalid maturity name");
+		return {
+			type,
+			chain_id,
+			timestamp: parseMaturity(timestampValue),
+			name: nameValue
+		};
+	}
+	if (type === "callback") {
+		const callbackTypeValue = rest[0] ?? "";
+		const addressValue = rest.slice(1).join(":");
+		if (!callbackTypeValue || !addressValue) throw new BadRequestError("Cursor must be in the format callback:chain_id:callback_type:address");
+		if (!isCallbackType(callbackTypeValue)) throw new BadRequestError("Cursor has an invalid callback type");
+		return {
+			type,
+			chain_id,
+			callback_type: callbackTypeValue,
+			address: parseAddress(addressValue, "Cursor address")
+		};
+	}
+	if (type === "loan_token" || type === "oracle") {
+		const addressValue = rest.join(":");
+		if (!addressValue) throw new BadRequestError(`Cursor must be in the format ${type}:chain_id:address`);
+		return {
+			type,
+			chain_id,
+			address: parseAddress(addressValue, "Cursor address")
+		};
+	}
+	throw new BadRequestError("Cursor has an invalid rule type");
+}
+function findStartIndex(rules, cursor) {
+	let low = 0;
+	let high = rules.length;
+	while (low < high) {
+		const mid = Math.floor((low + high) / 2);
+		const current = rules[mid];
+		if (compareConfigRules(current, cursor) <= 0) low = mid + 1;
+		else high = mid;
+	}
+	return low;
+}
+function parseAddress(address, label) {
+	if (!/^0x[a-fA-F0-9]{40}$/.test(address)) throw new BadRequestError(`${label} must be a valid 20-byte address`);
+	return address.toLowerCase();
+}
+function isConfigRuleType(value) {
+	return value === "maturity" || value === "callback" || value === "loan_token" || value === "oracle";
+}
+function isMaturityType(value) {
+	return Object.values(MaturityType).includes(value);
+}
+function parseMaturity(value) {
+	try {
+		return from$16(value);
+	} catch (err) {
+		throw new BadRequestError(err instanceof Error ? err.message : "Invalid maturity timestamp");
+	}
+}
+function isCallbackType(value) {
+	if (value === Type$1.BuyWithEmptyCallback) return false;
+	return Object.values(Type$1).includes(value);
+}
+
+//#endregion
+//#region src/api/Controllers/getDocs.ts
+const __dirname = (() => {
+	try {
+		return dirname(fileURLToPath(import.meta.url));
+	} catch {
+		return process.cwd();
+	}
+})();
+/**
+* Build the OpenAPI document for the router.
+* @returns OpenAPI document. {@link OpenAPIDocument}
+*/
+async function getSwaggerJson() {
+	return OpenApi();
+}
+/**
+* Render the API documentation HTML page.
+* @returns HTML page as string.
+*/
+async function getDocsHtml() {
+	const spec = await OpenApi();
+	return `<!DOCTYPE html>
+<html>
+  <head>
+    <meta charset="UTF-8">
+    <title>Router API Docs (Scalar)</title>
+    <script src="https://cdn.jsdelivr.net/npm/@scalar/api-reference"><\/script>
+    <style>
+      html, body { margin: 0; height: 100%; }
+      api-reference { height: 100%; width: 100%; }
+    </style>
+  </head>
+  <body>
+    <div id="api-container" style="height:100%;width:100%;"></div>
+    <script>
+      window.addEventListener('load', function () {
+        const spec = ${JSON.stringify(spec)};
+        Scalar.createApiReference('#api-container', { spec: { content: spec, hideModels: true } });
+      });
+    <\/script>
+  </body>
+</html>`;
+}
+/**
+* Finds the integrator.md file.
+* Handles source, bundled CLI, and Lambda scenarios.
+*/
+function findIntegratorMd() {
+	const candidates = [
+		resolve(__dirname, "../../../docs/integrator.md"),
+		resolve(__dirname, "../docs/integrator.md"),
+		resolve(process.cwd(), "docs/integrator.md")
+	];
+	for (const candidate of candidates) if (existsSync(candidate)) return candidate;
+	throw new Error(`integrator.md not found. Tried: ${candidates.join(", ")}`);
+}
+/**
+* Renders the integrator documentation as HTML.
+* @returns HTML page with the rendered markdown documentation.
+*/
+async function getIntegratorDocsHtml() {
+	return `<!DOCTYPE html>
+<html>
+  <head>
+    <meta charset="UTF-8">
+    <title>Documentation</title>
+    <style>
+      body { font-family: system-ui, sans-serif; max-width: 800px; margin: 0 auto; padding: 2rem; line-height: 1.6; }
+      pre { background: #f4f4f4; padding: 1rem; overflow-x: auto; }
+      code { background: #f4f4f4; padding: 0.2rem 0.4rem; }
+      a { color: #0066cc; }
+    </style>
+  </head>
+  <body>
+    <nav><a href="/docs/api">API Reference &rarr;</a></nav>
+    ${await marked(await readFile(findIntegratorMd(), "utf-8"))}
+  </body>
+</html>`;
+}
+
+//#endregion
+//#region src/api/Controllers/getHealth.ts
+async function getHealth(query, db, chainRegistry) {
+	const logger = getLogger();
+	try {
+		const parsed = safeParse("get_health", query);
+		if (!parsed.success) return failure(parsed.error);
+		const snapshot = await create$16({
+			db,
+			chainRegistry
+		}).getSnapshot();
+		if (parsed.data.strict && !snapshot.initialized) return failure(new APIError(STATUS_CODE.INTERNAL_SERVER_ERROR, "Indexer block state is not initialized", "INTERNAL_SERVER_ERROR", toSnakeCase$1({
+			missingChains: snapshot.missingChains,
+			missingCollectors: snapshot.missingCollectors
+		})));
+		return success({ data: toSnakeCase$1({
+			status: snapshot.status,
+			initialized: snapshot.initialized,
+			missingChains: snapshot.missingChains,
+			missingCollectors: snapshot.missingCollectors
+		}) });
+	} catch (err) {
+		logger.error({
+			err,
+			msg: "Error getting health status",
+			errorMessage: err instanceof Error ? err.message : String(err),
+			errorStack: err instanceof Error ? err.stack : void 0
+		});
+		return failure(err);
+	}
+}
+async function getHealthChains(query, db, healthClients, chainRegistry) {
+	const logger = getLogger();
+	try {
+		const parsed = safeParse("get_health_chains", query);
+		if (!parsed.success) return failure(parsed.error);
+		const snapshot = await create$16({
+			db,
+			healthClients,
+			chainRegistry
+		}).getSnapshot();
+		if (parsed.data.strict && !snapshot.initialized) return failure(new APIError(STATUS_CODE.INTERNAL_SERVER_ERROR, "Indexer block state is not initialized", "INTERNAL_SERVER_ERROR", toSnakeCase$1({
+			missingChains: snapshot.missingChains,
+			missingCollectors: snapshot.missingCollectors
+		})));
+		const chains = snapshot.chains;
+		return success({ data: chains.map(({ chainId, localBlockNumber, remoteBlockNumber, updatedAt, initialized }) => toSnakeCase$1({
+			chainId,
+			localBlockNumber,
+			remoteBlockNumber,
+			updatedAt,
+			initialized
+		})) });
+	} catch (err) {
+		logger.error({
+			err,
+			msg: "Error getting health status for chains",
+			errorMessage: err instanceof Error ? err.message : String(err),
+			errorStack: err instanceof Error ? err.stack : void 0
+		});
+		return failure(err);
+	}
+}
+async function getHealthCollectors(query, db, chainRegistry) {
+	const logger = getLogger();
+	try {
+		const parsed = safeParse("get_health_collectors", query);
+		if (!parsed.success) return failure(parsed.error);
+		const snapshot = await create$16({
+			db,
+			chainRegistry
+		}).getSnapshot();
+		if (parsed.data.strict && !snapshot.initialized) return failure(new APIError(STATUS_CODE.INTERNAL_SERVER_ERROR, "Indexer block state is not initialized", "INTERNAL_SERVER_ERROR", toSnakeCase$1({
+			missingChains: snapshot.missingChains,
+			missingCollectors: snapshot.missingCollectors
+		})));
+		const collectors = snapshot.collectors;
+		return success({ data: collectors.map(({ name, chainId, blockNumber, updatedAt, lag, status, initialized }) => toSnakeCase$1({
+			name,
+			chainId,
+			blockNumber,
+			updatedAt,
+			lag,
+			status,
+			initialized
+		})) });
+	} catch (err) {
+		logger.error({
+			err,
+			msg: "Error getting health status for collectors",
+			errorMessage: err instanceof Error ? err.message : String(err),
+			errorStack: err instanceof Error ? err.stack : void 0
+		});
+		return failure(err);
+	}
+}
+
+//#endregion
+//#region src/api/Controllers/getObligation.ts
+async function getObligation(params, db) {
+	const logger = getLogger();
+	const result = safeParse("get_obligation", params, (issue) => issue.message);
+	if (!result.success) return failure(result.error);
+	const query = result.data;
+	try {
+		const { obligations } = await db.offers.getObligations({ ids: [query.obligation_id] });
+		if (obligations.length === 0) return failure(new NotFoundError("Obligation not found"));
+		const obligation = obligations[0];
+		const [quote] = await db.offers.getQuotes({ obligationIds: [id(obligation)] });
+		return success({
+			data: from$4(obligation, quote ?? {
+				obligationId: id(obligation),
+				ask: { price: 0n },
+				bid: { price: 0n }
+			}),
+			cursor: null
+		});
+	} catch (err) {
+		logger.error({
+			err,
+			msg: "Error get obligation",
+			errorMessage: err instanceof Error ? err.message : String(err),
+			errorStack: err instanceof Error ? err.stack : void 0
+		});
+		return failure(err);
+	}
+}
+
+//#endregion
+//#region src/api/Controllers/getObligations.ts
+async function getObligations$1(queryParameters, db) {
+	const logger = getLogger();
+	const result = safeParse("get_obligations", queryParameters, (issue) => issue.message);
+	if (!result.success) return failure(result.error);
+	const query = result.data;
+	try {
+		const chainIds = query.chains?.length ? query.chains : void 0;
+		const loanTokens = query.loan_tokens?.length ? query.loan_tokens : void 0;
+		const collateralTokens = query.collateral_tokens?.length ? query.collateral_tokens : void 0;
+		const maturities = query.maturities?.length ? query.maturities : void 0;
+		const { obligations, nextCursor } = await db.offers.getObligations({
+			cursor: query.cursor,
+			limit: query.limit,
+			chainId: chainIds,
+			loanToken: loanTokens,
+			collateralToken: collateralTokens,
+			maturity: maturities
+		});
+		const quotes = await db.offers.getQuotes({ obligationIds: obligations.map((o) => id(o)) });
+		return success({
+			data: obligations.map((o) => from$4(o, quotes.find((q) => q.obligationId === id(o)) ?? {
+				obligationId: id(o),
+				ask: { price: 0n },
+				bid: { price: 0n }
+			})),
+			cursor: nextCursor ?? null
+		});
+	} catch (err) {
+		logger.error({
+			err,
+			msg: "Error get obligations",
+			errorMessage: err instanceof Error ? err.message : String(err),
+			errorStack: err instanceof Error ? err.stack : void 0
+		});
+		return failure(err);
+	}
+}
+
+//#endregion
+//#region src/database/constants.ts
+/**
+* Default batch size for bulk database inserts.
+*
+* PostgreSQL limits a single query to at most 65,535 parameters
+* (e.g. $1, $2, ...). In bulk inserts, each row consumes one
+* parameter per column, so inserting too many rows at once can
+* exceed this limit.
+*
+* Our largest batched insert is into the `offers` table with 15 columns.
+* 15 cols × 4,000 rows = 60,000 parameters, safely under 65,535.
+*/
+const DEFAULT_BATCH_SIZE$1 = 4e3;
 
 //#endregion
 //#region src/database/domains/Offers.ts
@@ -7554,13 +7512,13 @@ function create$15(config) {
         jsonb_agg(
           jsonb_build_object(
             'asset', ${obligationCollateralsV2.asset},
-            'oracle', ${oracles.address},
+            'oracle', ${oracles$1.address},
             'lltv', ${obligationCollateralsV2.lltv}
           )
         ),
         '[]'::jsonb
-      )`.as("collaterals") }).from(obligationCollateralsV2).innerJoin(oracles, sql`${obligationCollateralsV2.oracleChainId} = ${oracles.chainId}
-             AND ${obligationCollateralsV2.oracleAddress} = ${oracles.address}`).where(eq(obligationCollateralsV2.obligationId, offers.obligationId)).as("collaterals_lateral");
+      )`.as("collaterals") }).from(obligationCollateralsV2).innerJoin(oracles$1, sql`${obligationCollateralsV2.oracleChainId} = ${oracles$1.chainId}
+             AND ${obligationCollateralsV2.oracleAddress} = ${oracles$1.address}`).where(eq(obligationCollateralsV2.obligationId, offers.obligationId)).as("collaterals_lateral");
 			const rows = (await db.select({
 				hash: offers.hash,
 				maker: offers.groupMaker,
@@ -7642,10 +7600,10 @@ function create$15(config) {
 				obligationId: obligations.obligationId,
 				chainId: obligations.chainId,
 				loanToken: obligations.loanToken,
-				collaterals: sql`ARRAY_AGG(jsonb_build_object('asset', ${obligationCollateralsV2.asset}, 'oracle', ${oracles.address}, 'lltv', ${obligationCollateralsV2.lltv}))`.as("collaterals"),
+				collaterals: sql`ARRAY_AGG(jsonb_build_object('asset', ${obligationCollateralsV2.asset}, 'oracle', ${oracles$1.address}, 'lltv', ${obligationCollateralsV2.lltv}))`.as("collaterals"),
 				maturity: obligations.maturity
-			}).from(obligations).innerJoin(obligationCollateralsV2, eq(obligations.obligationId, obligationCollateralsV2.obligationId)).innerJoin(oracles, sql`${obligationCollateralsV2.oracleChainId} = ${oracles.chainId}
-             AND ${obligationCollateralsV2.oracleAddress} = ${oracles.address}`).groupBy(obligations.obligationId).where(and(cursor !== null && cursor !== void 0 ? gt(obligations.obligationId, cursor) : sql`true`, ids !== void 0 && ids.length > 0 ? inArray(obligations.obligationId, ids) : void 0, chainIds !== void 0 && chainIds.length > 0 ? inArray(obligations.chainId, chainIds) : void 0, loanTokenFilter, maturities !== void 0 && maturities.length > 0 ? inArray(obligations.maturity, maturities) : gte(obligations.maturity, now$1), collateralFilter)).orderBy(asc(obligations.obligationId)).limit(limit);
+			}).from(obligations).innerJoin(obligationCollateralsV2, eq(obligations.obligationId, obligationCollateralsV2.obligationId)).innerJoin(oracles$1, sql`${obligationCollateralsV2.oracleChainId} = ${oracles$1.chainId}
+             AND ${obligationCollateralsV2.oracleAddress} = ${oracles$1.address}`).groupBy(obligations.obligationId).where(and(cursor !== null && cursor !== void 0 ? gt(obligations.obligationId, cursor) : sql`true`, ids !== void 0 && ids.length > 0 ? inArray(obligations.obligationId, ids) : void 0, chainIds !== void 0 && chainIds.length > 0 ? inArray(obligations.chainId, chainIds) : void 0, loanTokenFilter, maturities !== void 0 && maturities.length > 0 ? inArray(obligations.maturity, maturities) : gte(obligations.maturity, now$1), collateralFilter)).orderBy(asc(obligations.obligationId)).limit(limit);
 			const items = [];
 			for (const row of result) items.push(from$15({
 				chainId: row.chainId,
@@ -7716,40 +7674,28 @@ async function getOffersQuery(db, parameters) {
 	if (cursor !== null && cursor !== void 0) {
 		if (!cursor.startsWith("0x") || cursor.length !== 66) throw new Error("Invalid cursor format");
 	}
+	const now = Math.floor((Date.now() - 1) / 1e3);
 	const collateralsLateral = db.select({ collaterals: sql`COALESCE(
         jsonb_agg(
           jsonb_build_object(
             'asset', ${obligationCollateralsV2.asset},
-            'oracle', ${oracles.address},
+            'oracle', ${oracles$1.address},
             'lltv', ${obligationCollateralsV2.lltv}
           )
         ),
         '[]'::jsonb
-      )`.as("collaterals") }).from(obligationCollateralsV2).innerJoin(oracles, sql`${obligationCollateralsV2.oracleChainId} = ${oracles.chainId}
-             AND ${obligationCollateralsV2.oracleAddress} = ${oracles.address}`).where(eq(obligationCollateralsV2.obligationId, offers.obligationId)).as("collaterals_lateral");
+      )`.as("collaterals") }).from(obligationCollateralsV2).innerJoin(oracles$1, sql`${obligationCollateralsV2.oracleChainId} = ${oracles$1.chainId}
+             AND ${obligationCollateralsV2.oracleAddress} = ${oracles$1.address}`).where(eq(obligationCollateralsV2.obligationId, offers.obligationId)).as("collaterals_lateral");
 	const availableLateral = db.select({ available: sql`COALESCE(SUM(
             CASE
-              -- If asset is null, position available is 0
               WHEN ${positions.asset} IS NULL THEN 0
-
-              -- Position asset matches loan token: no conversion needed
-              WHEN ${positions.asset} = ${obligations.loanToken} THEN
+              ELSE
                 CASE
                   WHEN ${callbacks.amount} IS NULL THEN COALESCE(${positions.balance}, 0)::numeric
                   ELSE LEAST(${callbacks.amount}::numeric, COALESCE(${positions.balance}, 0)::numeric)
                 END
-
-              -- Position asset is collateral: apply oracle price * lltv
-              -- Formula: balance * price / 1e36 * lltv / 1e18
-              ELSE
-                (CASE
-                  WHEN ${callbacks.amount} IS NULL THEN COALESCE(${positions.balance}, 0)::numeric
-                  ELSE LEAST(${callbacks.amount}::numeric, COALESCE(${positions.balance}, 0)::numeric)
-                END)
-                * COALESCE(${oracles.price}, 0)::numeric / 1e36
-                * COALESCE(${obligationCollateralsV2.lltv}, 0)::numeric / 1e18
             END
-          ), 0)`.as("available") }).from(offersCallbacks).innerJoin(callbacks, eq(offersCallbacks.callbackId, callbacks.id)).innerJoin(positions, and(eq(callbacks.positionChainId, positions.chainId), eq(callbacks.positionContract, positions.contract), eq(callbacks.positionUser, positions.user))).leftJoin(obligationCollateralsV2, and(eq(obligationCollateralsV2.obligationId, offers.obligationId), eq(obligationCollateralsV2.asset, positions.asset))).leftJoin(oracles, and(eq(oracles.chainId, obligationCollateralsV2.oracleChainId), eq(oracles.address, obligationCollateralsV2.oracleAddress))).where(eq(offersCallbacks.offerHash, offers.hash)).as("available_lateral");
+          ), 0)`.as("available") }).from(offersCallbacks).innerJoin(callbacks, eq(offersCallbacks.callbackId, callbacks.id)).innerJoin(positions, and(eq(callbacks.positionChainId, positions.chainId), eq(callbacks.positionContract, positions.contract), eq(callbacks.positionUser, positions.user))).where(eq(offersCallbacks.offerHash, offers.hash)).as("available_lateral");
 	const rows = (await db.select({
 		hash: offers.hash,
 		maker: offers.groupMaker,
@@ -7771,17 +7717,24 @@ async function getOffersQuery(db, parameters) {
 		collaterals: collateralsLateral.collaterals,
 		blockNumber: offers.blockNumber,
 		available: sql`COALESCE(${availableLateral.available}::numeric, 0)`.as("available"),
-		takeable: sql`FLOOR(GREATEST(
-            0,
-            LEAST(
-              ${offers.assets}::numeric - ${groups.consumed}::numeric,
-              COALESCE(${availableLateral.available}::numeric, 0)
-            )
+		takeable: sql`FLOOR(GREATEST(0,
+            CASE WHEN ${offers.buy} = false
+              THEN ${offers.assets}::numeric - ${groups.consumed}::numeric
+              ELSE LEAST(
+                ${offers.assets}::numeric - ${groups.consumed}::numeric,
+                COALESCE(${availableLateral.available}::numeric, 0)
+              )
+            END
           ))`.as("takeable")
-	}).from(offers).innerJoin(obligations, eq(offers.obligationId, obligations.obligationId)).innerJoin(groups, and(eq(offers.groupChainId, groups.chainId), eq(offers.groupMaker, groups.maker), eq(offers.group, groups.group))).innerJoinLateral(collateralsLateral, sql`true`).leftJoinLateral(availableLateral, sql`true`).where(and(cursor !== null && cursor !== void 0 ? gt(offers.hash, cursor) : void 0, maker !== void 0 ? eq(offers.groupMaker, maker.toLowerCase()) : void 0, maker === void 0 ? sql`GREATEST(0, LEAST(
-                  ${offers.assets}::numeric - ${groups.consumed}::numeric,
-                  COALESCE(${availableLateral.available}::numeric, 0)
-                )) > 0` : void 0)).orderBy(asc(offers.hash)).limit(limit)).map((row) => {
+	}).from(offers).innerJoin(obligations, eq(offers.obligationId, obligations.obligationId)).innerJoin(groups, and(eq(offers.groupChainId, groups.chainId), eq(offers.groupMaker, groups.maker), eq(offers.group, groups.group))).innerJoinLateral(collateralsLateral, sql`true`).leftJoinLateral(availableLateral, sql`true`).where(and(cursor !== null && cursor !== void 0 ? gt(offers.hash, cursor) : void 0, maker !== void 0 ? eq(offers.groupMaker, maker.toLowerCase()) : void 0, gte(offers.expiry, now), gte(offers.maturity, now), maker === void 0 ? sql`GREATEST(0,
+                  CASE WHEN ${offers.buy} = false
+                    THEN ${offers.assets}::numeric - ${groups.consumed}::numeric
+                    ELSE LEAST(
+                      ${offers.assets}::numeric - ${groups.consumed}::numeric,
+                      COALESCE(${availableLateral.available}::numeric, 0)
+                    )
+                  END
+                ) > 0` : void 0)).orderBy(asc(offers.hash)).limit(limit)).map((row) => {
 		return {
 			hash: row.hash,
 			maker: row.maker,
@@ -7891,64 +7844,6 @@ async function getUserPositions(queryParameters, db) {
 	}
 }
 
-//#endregion
-//#region src/gatekeeper/CallbackTypes.ts
-/**
-* Resolve callback types for a list of callback addresses grouped by chain.
-* @param parameters - Resolve parameters. {@link resolveCallbackTypes.Parameters}
-* @returns Callback types grouped by chain. {@link resolveCallbackTypes.ReturnType}
-* @throws If a chain id is unknown.
-*/
-function resolveCallbackTypes$1(parameters) {
-	const { chains, request } = parameters;
-	const chainsById = new Map(chains.map((chain) => [chain.id, chain]));
-	return request.callbacks.map(({ chain_id, addresses }) => {
-		const chain = chainsById.get(chain_id);
-		if (!chain) throw new Error(`Unknown chain id ${chain_id}`);
-		const buckets = /* @__PURE__ */ new Map();
-		const uniqueAddresses = new Set(addresses.map((address) => address.toLowerCase()));
-		for (const address of uniqueAddresses) {
-			const bucketKey = getCallbackType(chain.name, address) ?? "not_supported";
-			const list = buckets.get(bucketKey) ?? [];
-			list.push(address);
-			buckets.set(bucketKey, list);
-		}
-		const response = { chain_id };
-		for (const [type, list] of buckets.entries()) response[type] = list;
-		if (!response.not_supported) response.not_supported = [];
-		return response;
-	});
-}
-
-//#endregion
-//#region src/api/Controllers/resolveCallbackTypes.ts
-/**
-* Resolve callback types for a list of callback addresses grouped by chain.
-* @param body - Request body with callback addresses. {@link CallbackTypesRequest}
-* @param chains - Chains to resolve callback types against. {@link Chain.Chain}
-* @returns Callback types grouped by chain. {@link CallbackTypesPayload}
-*/
-async function resolveCallbackTypes(body, chains) {
-	const result = safeParse("callback_types", body, (issue) => issue.message);
-	if (!result.success) return failure(result.error);
-	const request = result.data;
-	const chainIds = new Set(chains.map((chain) => chain.id));
-	const unknown = request.callbacks.find((entry) => !chainIds.has(entry.chain_id));
-	if (unknown) return failure(new BadRequestError(`Unknown chain id ${unknown.chain_id}`));
-	try {
-		const data = resolveCallbackTypes$1({
-			chains,
-			request
-		});
-		return success({
-			data,
-			cursor: null
-		});
-	} catch (err) {
-		return failure(err);
-	}
-}
-
 //#endregion
 //#region src/api/Controllers/validateOffers.ts
 async function validateOffers(body, gatekeeper) {
@@ -8028,7 +7923,6 @@ var Controllers_exports = /* @__PURE__ */ __exportAll({
 	getOffersQuery: () => getOffersQuery,
 	getSwaggerJson: () => getSwaggerJson,
 	getUserPositions: () => getUserPositions,
-	resolveCallbackTypes: () => resolveCallbackTypes,
 	validateOffers: () => validateOffers
 });
 
@@ -8101,24 +7995,9 @@ function serve$1(parameters) {
 			const { statusCode, body } = await gatekeeper.validate(reqBody);
 			return c.json(body, statusCode);
 		} catch (err) {
-			const failure$1 = failure(err);
-			return c.json(failure$1.body, failure$1.statusCode);
-		}
-	});
-	app.post("/v1/callbacks", async (c) => {
-		let body;
-		try {
-			body = await c.req.json();
-		} catch (err) {
-			const failure$3 = failure(err);
-			return c.json(failure$3.body, failure$3.statusCode);
-		}
-		if (body === null || typeof body !== "object") {
-			const failure$2 = failure(new BadRequestError("Request body must be a JSON object"));
+			const failure$2 = failure(err);
 			return c.json(failure$2.body, failure$2.statusCode);
 		}
-		const { statusCode, body: responseBody } = await resolveCallbackTypes(body, chainRegistry.list());
-		return c.json(responseBody, statusCode);
 	});
 	app.get("/v1/users/:userAddress/positions", async (c) => {
 		const query = c.req.query();
@@ -8150,8 +8029,8 @@ function serve$1(parameters) {
 			const { statusCode, body } = await gatekeeper.getConfigRules(c.req.query());
 			return c.json(body, statusCode);
 		} catch (err) {
-			const failure$4 = failure(err);
-			return c.json(failure$4.body, failure$4.statusCode);
+			const failure$1 = failure(err);
+			return c.json(failure$1.body, failure$1.statusCode);
 		}
 	});
 	app.get("/docs/openapi", async (c) => c.text(JSON.stringify(await getSwaggerJson()), 200, { "Content-Type": "application/json; charset=utf-8" }));
@@ -8168,7 +8047,6 @@ function serve$1(parameters) {
 var RouterApi_exports = /* @__PURE__ */ __exportAll({
 	BookResponse: () => BookResponse_exports,
 	BooksController: () => BooksController,
-	CallbacksController: () => CallbacksController,
 	ChainHealth: () => ChainHealth,
 	ChainsHealthResponse: () => ChainsHealthResponse,
 	CollectorHealth: () => CollectorHealth,
@@ -8390,7 +8268,7 @@ var drizzle_exports = /* @__PURE__ */ __exportAll({
 	offers: () => offers,
 	offersCallbacks: () => offersCallbacks,
 	offsets: () => offsets,
-	oracles: () => oracles,
+	oracles: () => oracles$1,
 	positionTypes: () => positionTypes,
 	positions: () => positions,
 	status: () => status,
@@ -8675,7 +8553,7 @@ async function _getOffers(db, params) {
               'lltv',   oc.lltv
             ) ORDER BY oc.asset), '[]'::jsonb) AS collaterals
       FROM ${obligationCollateralsV2} oc
-      JOIN ${oracles} oracle
+      JOIN ${oracles$1} oracle
         ON oracle.chain_id = oc.oracle_chain_id
         AND oracle.address  = oc.oracle_address
       WHERE oc.obligation_id = ${obligationId}
@@ -8830,35 +8708,15 @@ async function _getOffers(db, params) {
         AND LOWER(pc.contract) = LOWER(c.position_contract)
         AND LOWER(pc."user") = LOWER(c.position_user)
     ),
-    -- Compute contribution per callback in loan terms (with oracle price via LEFT JOIN)
+    -- Compute contribution per callback in loan terms (loan token only — collateral positions are not indexed)
     callback_loan_contribution AS (
       SELECT
         cc.*,
         CASE
-          -- No lot exists: contribution is 0
           WHEN cc.lot_lower IS NULL THEN 0
-          -- Loan token position: use lot_balance directly, apply callback limit
-          WHEN LOWER(cc.position_asset) = LOWER(cc.loan_token) THEN
-            LEAST(
-              cc.lot_balance,
-              COALESCE(cc.callback_amount::numeric, cc.lot_balance)
-            )
-          -- Collateral position: convert to loan using (amount * price / 10^36) * lltv / 10^18
-          ELSE
-            (
-              LEAST(
-                cc.lot_balance,
-                COALESCE(cc.callback_amount::numeric, cc.lot_balance)
-              ) * COALESCE(collat_oracle.price::numeric, 0) / 1e36
-            ) * COALESCE(collat_info.lltv::numeric, 0) / 1e18
+          ELSE LEAST(cc.lot_balance, COALESCE(cc.callback_amount::numeric, cc.lot_balance))
         END AS contribution_in_loan
       FROM callback_contributions cc
-      LEFT JOIN ${obligationCollateralsV2} collat_info
-        ON collat_info.obligation_id = cc.obligation_id
-        AND LOWER(collat_info.asset) = LOWER(cc.position_asset)
-      LEFT JOIN ${oracles} collat_oracle
-        ON collat_oracle.chain_id = collat_info.oracle_chain_id
-        AND LOWER(collat_oracle.address) = LOWER(collat_info.oracle_address)
     ),
     -- Aggregate contributions per offer, deduplicating by position using DISTINCT ON
     offer_contributions AS (
@@ -8895,6 +8753,22 @@ async function _getOffers(db, params) {
       GROUP BY hash, obligation_id, assets, price, obligation_units, obligation_shares, maturity, expiry, start, group_group, buy,
                callback_address, callback_data, block_number, group_chain_id, group_maker,
                consumed, chain_id, loan_token, session
+      UNION ALL
+      -- Sell offers without callbacks: collateral positions not indexed, takeable = assets - consumed
+      SELECT
+        p.hash, p.obligation_id, p.assets, p.price,
+        p.obligation_units, p.obligation_shares,
+        p.maturity, p.expiry, p.start, p.group_group,
+        p.buy, p.callback_address, p.callback_data,
+        p.block_number, p.group_chain_id, p.group_maker,
+        p.consumed, p.chain_id, p.loan_token, p.session,
+        0 AS total_available
+      FROM paged p
+      WHERE p.buy = false
+        AND NOT EXISTS (
+          SELECT 1 FROM ${offersCallbacks} oc2
+          WHERE oc2.offer_hash = p.hash
+        )
     )
     -- Final SELECT with inline takeable computation
     SELECT
@@ -8917,18 +8791,24 @@ async function _getOffers(db, params) {
       oc.block_number,
       oc.session,
       COALESCE(oc.total_available, 0) AS available,
-      -- takeable = min(assets - consumed, total_available)
-      GREATEST(0, LEAST(
-        oc.assets::numeric - oc.consumed::numeric,
-        COALESCE(oc.total_available, 0)
-      )) AS takeable,
+      -- takeable: sell offers use assets - consumed directly (collateral positions not indexed yet)
+      CASE WHEN oc.buy = false
+        THEN GREATEST(0, oc.assets::numeric - oc.consumed::numeric)
+        ELSE GREATEST(0, LEAST(
+          oc.assets::numeric - oc.consumed::numeric,
+          COALESCE(oc.total_available, 0)
+        ))
+      END AS takeable,
       c.collaterals
     FROM offer_contributions oc
     LEFT JOIN collats c ON c.obligation_id = oc.obligation_id
-    WHERE GREATEST(0, LEAST(
-      oc.assets::numeric - oc.consumed::numeric,
-      COALESCE(oc.total_available, 0)
-    )) > 0
+    WHERE CASE WHEN oc.buy = false
+      THEN GREATEST(0, oc.assets::numeric - oc.consumed::numeric)
+      ELSE GREATEST(0, LEAST(
+        oc.assets::numeric - oc.consumed::numeric,
+        COALESCE(oc.total_available, 0)
+      ))
+    END > 0
     ORDER BY
       oc.price::numeric ${priceSortDirection === "asc" ? sql`ASC` : sql`DESC`},
       oc.block_number ASC,
@@ -9269,32 +9149,32 @@ function create$5(db) {
 	return {
 		get: async ({ chainId }) => {
 			return (await db.select({
-				address: oracles.address,
-				price: oracles.price,
-				blockNumber: oracles.blockNumber,
-				chainId: oracles.chainId
-			}).from(oracles).where(eq(oracles.chainId, chainId))).map((r) => from$13({
+				address: oracles$1.address,
+				price: oracles$1.price,
+				blockNumber: oracles$1.blockNumber,
+				chainId: oracles$1.chainId
+			}).from(oracles$1).where(eq(oracles$1.chainId, chainId))).map((r) => from$13({
 				chainId: r.chainId,
 				address: r.address,
 				price: r.price,
 				blockNumber: r.blockNumber
 			}));
 		},
-		upsert: async (oracles$1) => {
-			if (oracles$1.length === 0) return;
-			const rows = oracles$1.map((o) => ({
+		upsert: async (oracles) => {
+			if (oracles.length === 0) return;
+			const rows = oracles.map((o) => ({
 				chainId: o.chainId,
 				address: o.address.toLowerCase(),
 				price: o.price !== null ? o.price.toString() : null,
 				blockNumber: o.blockNumber
 			}));
 			await db.transaction(async (dbTx) => {
-				for (const batch of batch$1(rows, DEFAULT_BATCH_SIZE$1)) await dbTx.insert(oracles).values(batch).onConflictDoUpdate({
-					target: [oracles.chainId, oracles.address],
+				for (const batch of batch$1(rows, DEFAULT_BATCH_SIZE$1)) await dbTx.insert(oracles$1).values(batch).onConflictDoUpdate({
+					target: [oracles$1.chainId, oracles$1.address],
 					set: {
-						price: sql`COALESCE(EXCLUDED.price, ${oracles.price})`,
+						price: sql`COALESCE(EXCLUDED.price, ${oracles$1.price})`,
 						blockNumber: sql`CASE
-                  WHEN EXCLUDED.price IS NULL THEN ${oracles.blockNumber}
+                  WHEN EXCLUDED.price IS NULL THEN ${oracles$1.blockNumber}
                   ELSE EXCLUDED.block_number
                 END`,
 						updatedAt: sql`NOW()`
@@ -10333,23 +10213,11 @@ function createHttpClient(config) {
 			issues: []
 		};
 	};
-	const getCallbackTypes = async (requestPayload) => {
-		const response = await request("/v1/callbacks", {
-			method: "POST",
-			headers: { "content-type": "application/json" },
-			body: JSON.stringify(requestPayload)
-		});
-		const json = await response.json();
-		if (!response.ok) throw new Error(`Gatekeeper callbacks request failed: ${extractErrorMessage(json) ?? response.statusText}`);
-		if (!("data" in json) || !Array.isArray(json.data)) throw new Error("Gatekeeper callbacks response is invalid.");
-		return json.data;
-	};
 	return {
 		baseUrl,
 		validate,
 		getConfigRules,
-		isAllowed,
-		getCallbackTypes
+		isAllowed
 	};
 }
 function mergeHeaders(base, extra) {
@@ -10478,6 +10346,7 @@ var Rules_exports = /* @__PURE__ */ __exportAll({
 	callback: () => callback,
 	chains: () => chains,
 	maturity: () => maturity,
+	oracle: () => oracle,
 	sameMaker: () => sameMaker,
 	token: () => token,
 	validity: () => validity
@@ -10485,109 +10354,13 @@ var Rules_exports = /* @__PURE__ */ __exportAll({
 /**
 * set of rules to validate offers.
 *
-* @param parameters - Validity parameters with chain and client
+* @param _parameters - Validity parameters with chain and client
 * @returns Array of validation rules to evaluate against offers
 */
-function validity(parameters) {
-	const { client } = parameters;
-	const sellErc20CallbackInvalid = single("sell_erc20_callback_invalid", "Validates that sell offers have valid ERC20 callback data matching offer collaterals", (offer) => {
-		const callbackType = getCallbackType(client.chain.name, offer.callback.address);
-		if (callbackType !== Type$1.SellERC20Callback) return;
-		const decoded = decode$2(callbackType, offer.callback.data);
-		if (decoded.length === 0) return { message: "Callback data cannot be decoded or is empty." };
-		if (callbackType === Type$1.SellERC20Callback) {
-			const offerCollaterals = new Set(offer.collaterals.map((c) => c.asset.toLowerCase()));
-			if (decoded.length !== offer.collaterals.length) return { message: `Sell callback collateral length mismatch. Expected ${offer.collaterals.length}, got ${decoded.length}.` };
-			for (const { contract } of decoded) if (!offerCollaterals.has(contract.toLowerCase())) return { message: "Sell callback collateral is not part of offer collaterals." };
-		}
-	});
-	const buyCallbackVaultInvalid = batch("buy_offers_callback_vault_invalid", "Validates that buy offers have valid vault callbacks registered in allowed factories with matching assets", async (offers) => {
-		const validationIssues = /* @__PURE__ */ new Map();
-		const offersByVaultAddress = /* @__PURE__ */ new Map();
-		for (let i = 0; i < offers.length; i++) {
-			const offer = offers[i];
-			if (getCallbackType(client.chain.name, offer.callback.address) !== Type$1.BuyVaultV1Callback) continue;
-			try {
-				const callbackVaults = decodeBuyVaultV1Callback(offer.callback.data);
-				for (const { contract } of callbackVaults) {
-					const normalizedVaultAddress = contract.toLowerCase();
-					if (!offersByVaultAddress.has(normalizedVaultAddress)) offersByVaultAddress.set(normalizedVaultAddress, []);
-					offersByVaultAddress.get(normalizedVaultAddress).push({
-						index: i,
-						offer
-					});
-				}
-			} catch (_) {}
-		}
-		const uniqueVaultAddresses = Array.from(offersByVaultAddress.keys());
-		if (uniqueVaultAddresses.length === 0) return validationIssues;
-		const allowedFactories = getCallback(client.chain.name, Type$1.BuyVaultV1Callback)?.vaultFactories.map((f) => f.toLowerCase());
-		if (!allowedFactories) return validationIssues;
-		const multicallContracts = [];
-		for (const vaultAddress of uniqueVaultAddresses) {
-			multicallContracts.push({
-				address: vaultAddress,
-				abi: ERC4626,
-				functionName: "asset"
-			});
-			for (const factoryAddress of allowedFactories) multicallContracts.push({
-				address: factoryAddress,
-				abi: MetaMorphoFactory,
-				functionName: "isMetaMorpho",
-				args: [vaultAddress]
-			});
-		}
-		const multicallResults = await multicall(client, {
-			contracts: multicallContracts,
-			allowFailure: true
-		});
-		const vaultAssetByAddress = /* @__PURE__ */ new Map();
-		const registeredVaults = /* @__PURE__ */ new Set();
-		const numberOfFactories = allowedFactories.length;
-		let resultIndex = 0;
-		for (const vaultAddress of uniqueVaultAddresses) {
-			const assetCallResult = multicallResults[resultIndex++];
-			const assetAddress = assetCallResult.status === "success" ? assetCallResult.result : null;
-			vaultAssetByAddress.set(vaultAddress, assetAddress);
-			let isRegisteredInFactory = false;
-			for (let factoryIndex = 0; factoryIndex < numberOfFactories; factoryIndex++) {
-				const factoryCallResult = multicallResults[resultIndex++];
-				if (factoryCallResult.status === "success" && factoryCallResult.result === true) isRegisteredInFactory = true;
-			}
-			if (isRegisteredInFactory) registeredVaults.add(vaultAddress);
-		}
-		const uniqueOffers = /* @__PURE__ */ new Map();
-		for (const offersArray of offersByVaultAddress.values()) for (const { index, offer } of offersArray) uniqueOffers.set(index, offer);
-		for (const [index, offer] of uniqueOffers) try {
-			const callbackVaults = decodeBuyVaultV1Callback(offer.callback.data);
-			const vaultsWithIssues = [];
-			for (const { contract } of callbackVaults) {
-				const normalizedVaultAddress = contract.toLowerCase();
-				const assetAddress = vaultAssetByAddress.get(normalizedVaultAddress);
-				const isRegistered = registeredVaults.has(normalizedVaultAddress);
-				const failureReasons = [];
-				if (assetAddress === null) failureReasons.push("asset call failed");
-				else if (assetAddress && assetAddress.toLowerCase() !== offer.loanToken.toLowerCase()) failureReasons.push("asset mismatch");
-				if (!isRegistered) failureReasons.push("not registered in factory");
-				if (failureReasons.length > 0) vaultsWithIssues.push({
-					vaultAddress: contract,
-					failureReasons: failureReasons.join(", ")
-				});
-			}
-			if (vaultsWithIssues.length > 0) {
-				const failureDetails = vaultsWithIssues.map((v) => `${v.vaultAddress} (${v.failureReasons})`).join("; ");
-				validationIssues.set(index, { message: `Buy offer callback vaults are invalid: ${failureDetails}` });
-			}
-		} catch (_) {}
-		return validationIssues;
-	});
-	return [
-		single("expiry", "Validates that offer has not expired", (offer) => {
-			if (offer.expiry < Math.floor(Date.now() / 1e3)) return { message: "Expiry mismatch" };
-		}),
-		sellErc20CallbackInvalid,
-		buyCallbackVaultInvalid
-	];
+function validity(_parameters) {
+	return [single("expiry", "Validates that offer has not expired", (offer) => {
+		if (offer.expiry < Math.floor(Date.now() / 1e3)) return { message: "Expiry mismatch" };
+	})];
 }
 const chains = ({ chains }) => single("chain_ids", `Validates that offer chain is one of: [${chains.map((c) => c.id).join(", ")}]`, (offer) => {
 	const allowedChainIds = chains.map((c) => c.id);
@@ -10597,12 +10370,10 @@ const maturity = ({ maturities }) => single("maturity", `Validates that offer ma
 	const allowedMaturities = maturities.map((m) => from$16(m));
 	if (!allowedMaturities.includes(offer.maturity)) return { message: `Maturity must be end of current month (${allowedMaturities[0]}) or end of next month (${allowedMaturities[1]}). Got: ${offer.maturity}` };
 });
-const callback = ({ callbacks, allowedAddresses }) => single("callback", `Validates callbacks: buy empty callback is ${callbacks.includes(Type$1.BuyWithEmptyCallback) ? "allowed" : "not allowed"}; sell offers must use a non-empty callback; non-empty callbacks must target one of [${allowedAddresses.map((a) => a.toLowerCase()).join(", ")}]`, (offer) => {
-	if (isEmptyCallback(offer) && offer.buy && !callbacks?.find((c) => c === Type$1.BuyWithEmptyCallback)) return { message: "Buy offers with empty callback not allowed." };
-	if (isEmptyCallback(offer) && !offer.buy) return { message: "Sell offers require a non-empty callback." };
-	if (!isEmptyCallback(offer)) {
-		if (!allowedAddresses.includes(offer.callback.address?.toLowerCase())) return { message: `Callback address ${offer.callback.address} is not allowed.` };
-	}
+const callback = ({ callbacks }) => single("callback", `Validates callbacks: buy empty callback is ${callbacks.includes(Type$1.BuyWithEmptyCallback) ? "allowed" : "not allowed"}; sell empty callback is ${callbacks.includes(Type$1.SellWithEmptyCallback) ? "allowed" : "not allowed"}; non-empty callbacks are rejected`, (offer) => {
+	if (!isEmptyCallback(offer)) return { message: "Non-empty callbacks are not supported." };
+	if (isEmptyCallback(offer) && offer.buy && !callbacks.includes(Type$1.BuyWithEmptyCallback)) return { message: "Buy offers with empty callback not allowed." };
+	if (isEmptyCallback(offer) && !offer.buy && !callbacks.includes(Type$1.SellWithEmptyCallback)) return { message: "Sell offers with empty callback not allowed." };
 });
 /**
 * A validation rule that checks if the offer's tokens are allowed for its chain.
@@ -10616,6 +10387,16 @@ const token = ({ assetsByChainId }) => single("token", "Validates that offer loa
 	if (offer.collaterals.some((collateral) => !allowedAssets.includes(collateral.asset.toLowerCase()))) return { message: "Collateral is not allowed" };
 });
 /**
+* A validation rule that checks if the offer's oracle addresses are allowed for its chain.
+* @param oraclesByChainId - Allowed oracles indexed by chain id.
+* @returns The issue that was found. If the offer is valid, this will be undefined.
+*/
+const oracle = ({ oraclesByChainId }) => single("oracle", "Validates that offer collateral oracles are in the allowed oracle list for the offer chain", (offer) => {
+	const allowedOracles = oraclesByChainId[offer.chainId]?.map((oracle) => oracle.toLowerCase());
+	if (!allowedOracles || allowedOracles.length === 0) return { message: `No allowed oracles for chain ${offer.chainId}` };
+	if (offer.collaterals.some((collateral) => !allowedOracles.includes(collateral.oracle.toLowerCase()))) return { message: "Oracle is not allowed" };
+});
+/**
 * A batch validation rule that ensures all offers in a tree have the same maker address.
 * Returns an issue only for the first non-conforming offer.
 * This rule is signing-agnostic; signer verification is handled at the collector level.
@@ -10646,21 +10427,22 @@ const amountMutualExclusivity = () => single("amount_mutual_exclusivity", "Valid
 //#region src/gatekeeper/morphoRules.ts
 const morphoRules = (chains$3) => {
 	const assetsByChainId = {};
-	for (const chain of chains$3) assetsByChainId[chain.id] = assets[chain.id.toString()] ?? [];
+	const oraclesByChainId = {};
+	for (const chain of chains$3) {
+		assetsByChainId[chain.id] = assets[chain.id.toString()] ?? [];
+		oraclesByChainId[chain.id] = oracles[chain.id.toString()] ?? [];
+	}
 	return [
 		sameMaker(),
 		amountMutualExclusivity(),
 		chains({ chains: chains$3 }),
 		maturity({ maturities: [MaturityType.EndOfMonth, MaturityType.EndOfNextMonth] }),
 		callback({
-			callbacks: [
-				Type$1.BuyWithEmptyCallback,
-				Type$1.BuyVaultV1Callback,
-				Type$1.SellERC20Callback
-			],
-			allowedAddresses: chains$3.flatMap((c) => getCallbackAddresses(c.name))
+			callbacks: [Type$1.BuyWithEmptyCallback, Type$1.SellWithEmptyCallback],
+			allowedAddresses: []
 		}),
-		token({ assetsByChainId })
+		token({ assetsByChainId }),
+		oracle({ oraclesByChainId })
 	];
 };
 
@@ -10842,5 +10624,5 @@ var mempool_exports = /* @__PURE__ */ __exportAll({
 });
 
 //#endregion
-export { Abi_exports as Abi, BookResponse_exports as BookResponse, BooksController, BrandTypeId, Callback_exports as Callback, CallbacksController, Chain_exports as Chain, ChainHealth, ChainRegistry_exports as ChainRegistry, ChainsHealthResponse, Collateral_exports as Collateral, CollectorHealth, CollectorsHealthResponse, ConfigContractsController, ConfigRulesController, Database_exports as Database, ERC4626_exports as ERC4626, Errors_exports as Errors, Format_exports as Format, Gatekeeper_exports as Gatekeeper, Client_exports as GatekeeperClient, Health_exports as Health, HealthController, Indexer_exports as Indexer, LLTV_exports as LLTV, Liquidity_exports as Liquidity, Logger_exports as Logger, Maturity_exports as Maturity, mempool_exports as Mempool, Obligation_exports as Obligation, ObligationResponse_exports as ObligationResponse, ObligationsController, Offer_exports as Offer, OfferResponse_exports as OfferResponse, OffersController, drizzle_exports as OffersSchema, OpenApi, Oracle_exports as Oracle, Position_exports as Position, PositionResponse_exports as PositionResponse, Quote_exports as Quote, RouterApi_exports as RouterApi, Client_exports$1 as RouterClient, RouterStatusResponse, Rules_exports as Rules, time_exports as Time, TradingFee_exports as TradingFee, Transfer_exports as Transfer, Tree_exports as Tree, UsersController, utils_exports as Utils, ValidateController, Gate_exports as Validation, morphoRules, parse, safeParse };
+export { Abi_exports as Abi, BookResponse_exports as BookResponse, BooksController, BrandTypeId, Callback_exports as Callback, Chain_exports as Chain, ChainHealth, ChainRegistry_exports as ChainRegistry, ChainsHealthResponse, Collateral_exports as Collateral, CollectorHealth, CollectorsHealthResponse, ConfigContractsController, ConfigRulesController, Database_exports as Database, ERC4626_exports as ERC4626, Errors_exports as Errors, Format_exports as Format, Gatekeeper_exports as Gatekeeper, Client_exports as GatekeeperClient, Health_exports as Health, HealthController, Indexer_exports as Indexer, LLTV_exports as LLTV, Liquidity_exports as Liquidity, Logger_exports as Logger, Maturity_exports as Maturity, mempool_exports as Mempool, Obligation_exports as Obligation, ObligationResponse_exports as ObligationResponse, ObligationsController, Offer_exports as Offer, OfferResponse_exports as OfferResponse, OffersController, drizzle_exports as OffersSchema, OpenApi, Oracle_exports as Oracle, Position_exports as Position, PositionResponse_exports as PositionResponse, Quote_exports as Quote, RouterApi_exports as RouterApi, Client_exports$1 as RouterClient, RouterStatusResponse, Rules_exports as Rules, time_exports as Time, TradingFee_exports as TradingFee, Transfer_exports as Transfer, Tree_exports as Tree, UsersController, utils_exports as Utils, ValidateController, Gate_exports as Validation, morphoRules, parse, safeParse };
 //# sourceMappingURL=index.node.mjs.map