@morpho-dev/router 0.10.0 → 0.11.0

package/dist/index.node.mjs

@@ -1,14 +1,12 @@
 import { t as __exportAll } from "./chunk-Bo1DHCg-.mjs";
-import { getBlock, getBlockNumber, getLogs, multicall } from "viem/actions";
+import { getBlockNumber, getLogs, multicall } from "viem/actions";
+import { SpanStatusCode, context, propagation, trace } from "@opentelemetry/api";
 import { AsyncLocalStorage } from "node:async_hooks";
 import { bytesToHex, concatHex, decodeAbiParameters, encodeAbiParameters, erc20Abi, getAddress, hashTypedData, hexToBytes, isAddress, isHex, keccak256, maxUint256, numberToHex, pad, parseAbi, parseEventLogs, publicActions, recoverAddress, stringify, zeroAddress } from "viem";
-import { SpanStatusCode, trace } from "@opentelemetry/api";
 import "@opentelemetry/exporter-trace-otlp-proto";
-import "@opentelemetry/id-generator-aws-xray";
 import "@opentelemetry/instrumentation";
 import "@opentelemetry/instrumentation-http";
 import "@opentelemetry/instrumentation-pg";
-import "@opentelemetry/propagator-aws-xray";
 import "@opentelemetry/resources";
 import "@opentelemetry/sdk-trace-node";
 import "@opentelemetry/semantic-conventions";
@@ -21,11 +19,11 @@ import { bigint, boolean, foreignKey, index, integer, numeric, pgSchema, primary
 import { serve } from "@hono/node-server";
 import { Hono } from "hono";
 import { cors } from "hono/cors";
+import crypto, { createHash, randomUUID } from "node:crypto";
 import { z } from "zod/v4";
 import "reflect-metadata";
 import { generateDocument } from "openapi-metadata";
 import { ApiBody, ApiOperation, ApiParam, ApiProperty, ApiQuery, ApiResponse, ApiTags } from "openapi-metadata/decorators";
-import crypto, { createHash } from "node:crypto";
 import { existsSync } from "node:fs";
 import { readFile } from "node:fs/promises";
 import { dirname, resolve } from "node:path";
@@ -39,11 +37,75 @@ import { drizzle as drizzle$1 } from "drizzle-orm/pglite";
 import { migrate as migrate$1 } from "drizzle-orm/pglite/migrator";
 import { Pool } from "pg";
 
+//#region src/observability/Events.ts
+const eventNamePattern = /^[a-z][a-z0-9_]*(?:\.[a-z][a-z0-9_]*)+$/;
+/**
+* Canonical telemetry event names used by router logs.
+* Every value must stay unique and follow dot-separated snake_case segments.
+*/
+const Events = defineEvents({
+	API_GET_BOOK_FAILED: "api.get_book.failed",
+	API_GET_HEALTH_CHAINS_FAILED: "api.get_health_chains.failed",
+	API_GET_HEALTH_COLLECTORS_FAILED: "api.get_health_collectors.failed",
+	API_GET_HEALTH_FAILED: "api.get_health.failed",
+	API_GET_OBLIGATION_FAILED: "api.get_obligation.failed",
+	API_GET_OBLIGATIONS_FAILED: "api.get_obligations.failed",
+	API_GET_OFFERS_FAILED: "api.get_offers.failed",
+	API_GET_USER_POSITIONS_FAILED: "api.get_user_positions.failed",
+	API_VALIDATE_OFFERS_FAILED: "api.validate_offers.failed",
+	HTTP_REQUEST_COMPLETED: "http.request.completed",
+	HTTP_REQUEST_FAILED: "http.request.failed",
+	INDEXER_COLLECTOR_EVENTS_INDEXED: "indexer.collector.events_indexed",
+	INDEXER_COLLECTOR_FAILED: "indexer.collector.failed",
+	INDEXER_COLLECTOR_FINALIZED_BLOCK_FAILED: "indexer.collector.finalized_block_failed",
+	INDEXER_COLLECTOR_GATEKEEPER_VALIDATION_FAILED: "indexer.collector.gatekeeper_validation_failed",
+	INDEXER_COLLECTOR_INVALID_CHAIN_CONFIG: "indexer.collector.invalid_chain_config",
+	INDEXER_COLLECTOR_LOG_SKIPPED: "indexer.collector.log_skipped",
+	INDEXER_COLLECTOR_MAX_BLOCK_REACHED: "indexer.collector.max_block_reached",
+	INDEXER_COLLECTOR_MISSING_BLOCKS: "indexer.collector.missing_blocks",
+	INDEXER_COLLECTOR_OFFERS_INDEXED: "indexer.collector.offers_indexed",
+	INDEXER_COLLECTOR_OFFER_TREE_DECODE_FAILED: "indexer.collector.offer_tree_decode_failed",
+	INDEXER_COLLECTOR_OFFER_TREE_REJECTED: "indexer.collector.offer_tree_rejected",
+	INDEXER_COLLECTOR_ORACLES_INDEXED: "indexer.collector.oracles_indexed",
+	INDEXER_COLLECTOR_ORACLE_FETCH_FAILED: "indexer.collector.oracle_fetch_failed",
+	INDEXER_COLLECTOR_POLL_FAILED: "indexer.collector.poll_failed",
+	INDEXER_COLLECTOR_POSITIONS_INDEXED: "indexer.collector.positions_indexed",
+	INDEXER_COLLECTOR_POSITIONS_INSERT_FAILED: "indexer.collector.positions_insert_failed",
+	INDEXER_COLLECTOR_POSITIONS_SNAPSHOT_FAILED: "indexer.collector.positions_snapshot_failed",
+	INDEXER_COLLECTOR_POSITION_CONVERSION_FAILED: "indexer.collector.position_conversion_failed",
+	INDEXER_COLLECTOR_REORG_COMPENSATED: "indexer.collector.reorg_compensated",
+	INDEXER_COLLECTOR_REORG_COMPENSATION_FAILED: "indexer.collector.reorg_compensation_failed",
+	INDEXER_COLLECTOR_REORG_DETECTED: "indexer.collector.reorg_detected",
+	INDEXER_COLLECTOR_RPC_QUERY_INVALID_RANGE: "indexer.collector.rpc_query_invalid_range",
+	INDEXER_COLLECTOR_STARTED: "indexer.collector.started",
+	INDEXER_COLLECTOR_TRANSFERS_INDEXED: "indexer.collector.transfers_indexed",
+	INDEXER_COLLECTOR_TRANSFERS_INSERT_FAILED: "indexer.collector.transfers_insert_failed"
+});
+const { API_GET_BOOK_FAILED, API_GET_HEALTH_CHAINS_FAILED, API_GET_HEALTH_COLLECTORS_FAILED, API_GET_HEALTH_FAILED, API_GET_OBLIGATION_FAILED, API_GET_OBLIGATIONS_FAILED, API_GET_OFFERS_FAILED, API_GET_USER_POSITIONS_FAILED, API_VALIDATE_OFFERS_FAILED, HTTP_REQUEST_COMPLETED, HTTP_REQUEST_FAILED, INDEXER_COLLECTOR_EVENTS_INDEXED, INDEXER_COLLECTOR_FAILED, INDEXER_COLLECTOR_FINALIZED_BLOCK_FAILED, INDEXER_COLLECTOR_GATEKEEPER_VALIDATION_FAILED, INDEXER_COLLECTOR_INVALID_CHAIN_CONFIG, INDEXER_COLLECTOR_LOG_SKIPPED, INDEXER_COLLECTOR_MAX_BLOCK_REACHED, INDEXER_COLLECTOR_MISSING_BLOCKS, INDEXER_COLLECTOR_OFFERS_INDEXED, INDEXER_COLLECTOR_OFFER_TREE_DECODE_FAILED, INDEXER_COLLECTOR_OFFER_TREE_REJECTED, INDEXER_COLLECTOR_ORACLES_INDEXED, INDEXER_COLLECTOR_ORACLE_FETCH_FAILED, INDEXER_COLLECTOR_POLL_FAILED, INDEXER_COLLECTOR_POSITIONS_INDEXED, INDEXER_COLLECTOR_POSITIONS_INSERT_FAILED, INDEXER_COLLECTOR_POSITIONS_SNAPSHOT_FAILED, INDEXER_COLLECTOR_POSITION_CONVERSION_FAILED, INDEXER_COLLECTOR_REORG_COMPENSATED, INDEXER_COLLECTOR_REORG_COMPENSATION_FAILED, INDEXER_COLLECTOR_REORG_DETECTED, INDEXER_COLLECTOR_RPC_QUERY_INVALID_RANGE, INDEXER_COLLECTOR_STARTED, INDEXER_COLLECTOR_TRANSFERS_INDEXED, INDEXER_COLLECTOR_TRANSFERS_INSERT_FAILED } = Events;
+function defineEvents(events) {
+	const names = Object.values(events);
+	validateUnique(names);
+	validatePattern(names);
+	return events;
+}
+function validateUnique(names) {
+	const seen = /* @__PURE__ */ new Set();
+	for (const name of names) {
+		if (seen.has(name)) throw new Error(`Duplicate telemetry event name: ${name}`);
+		seen.add(name);
+	}
+}
+function validatePattern(names) {
+	for (const name of names) if (!eventNamePattern.test(name)) throw new Error(`Invalid telemetry event name: ${name}`);
+}
+
+//#endregion
 //#region src/logger/Logger.ts
 var Logger_exports = /* @__PURE__ */ __exportAll({
 	LogLevelValues: () => LogLevelValues,
 	defaultLogger: () => defaultLogger,
 	getLogger: () => getLogger,
+	runWithLogContext: () => runWithLogContext,
 	runWithLogger: () => runWithLogger,
 	silentLogger: () => silentLogger
 });
@@ -65,15 +127,16 @@ function defaultLogger(minLevel, pretty) {
 	}, {});
 	const isEnabled = (methodLevel) => levelIndexByName[methodLevel] >= levelIndexByName[threshold];
 	const wrap = (consoleMethod, methodLevel) => isEnabled(methodLevel) ? (entry) => {
+		const normalizedEntry = normalizeLogEntry(entry);
 		if (!prettyEnabled) {
 			console[consoleMethod](stringify({
 				level: methodLevel,
-				...entry
+				...normalizedEntry
 			}));
 			return;
 		}
-		const { msg, ...rest } = entry;
-		const stack = typeof rest.stack === "string" ? rest.stack : void 0;
+		const { msg, ...rest } = normalizedEntry;
+		const stack = typeof rest.stack === "string" ? rest.stack : getErrorStack(rest.err);
 		if (stack) delete rest.stack;
 		const timestamp = (/* @__PURE__ */ new Date()).toISOString();
 		const level = methodLevel.toUpperCase();
@@ -103,11 +166,40 @@ function silentLogger() {
 	};
 }
 const loggerContext = new AsyncLocalStorage();
+const logEntryContext = new AsyncLocalStorage();
 function runWithLogger(logger, fn) {
 	return loggerContext.run(logger, fn);
 }
+/**
+* Run a function with additional context fields attached to every log entry emitted via {@link getLogger}.
+* Nested calls merge context (inner keys override outer keys).
+* @param context - Static fields added to all log entries in this scope.
+* @param fn - Async function to run with the scoped logging context.
+* @returns The result of the function.
+*/
+function runWithLogContext(context, fn) {
+	const inheritedContext = logEntryContext.getStore() ?? {};
+	return logEntryContext.run({
+		...inheritedContext,
+		...context
+	}, fn);
+}
 function getLogger() {
-	return loggerContext.getStore() ?? defaultLogger();
+	const scopedLogger = loggerContext.getStore() ?? defaultLogger();
+	const scopedContext = logEntryContext.getStore();
+	if (!scopedContext || Object.keys(scopedContext).length === 0) return scopedLogger;
+	const withContext = (logFn) => (entry) => logFn({
+		...scopedContext,
+		...entry
+	});
+	return {
+		trace: withContext(scopedLogger.trace),
+		debug: withContext(scopedLogger.debug),
+		info: withContext(scopedLogger.info),
+		warn: withContext(scopedLogger.warn),
+		error: withContext(scopedLogger.error),
+		fatal: withContext(scopedLogger.fatal)
+	};
 }
 function formatValue(value) {
 	if (value === null || value === void 0 || typeof value === "number" || typeof value === "bigint" || typeof value === "boolean") return String(value);
@@ -125,6 +217,112 @@ function formatValue(value) {
 		}
 	}
 }
+function normalizeLogEntry(entry) {
+	return normalizeUnknown(entry, /* @__PURE__ */ new WeakSet());
+}
+function normalizeUnknown(value, path) {
+	if (value instanceof Error) return serializeError(value, path);
+	if (value instanceof Date) return Number.isNaN(value.getTime()) ? null : value.toISOString();
+	if (Array.isArray(value)) {
+		if (path.has(value)) return "[Circular]";
+		path.add(value);
+		try {
+			return value.map((item) => normalizeUnknown(item, path));
+		} finally {
+			path.delete(value);
+		}
+	}
+	if (value && typeof value === "object") {
+		if (path.has(value)) return "[Circular]";
+		path.add(value);
+		try {
+			return Object.fromEntries(Object.entries(value).map(([key, nested]) => [key, normalizeUnknown(nested, path)]));
+		} finally {
+			path.delete(value);
+		}
+	}
+	return value;
+}
+function serializeError(error, path) {
+	if (path.has(error)) return {
+		name: error.name,
+		message: error.message,
+		circular: true
+	};
+	path.add(error);
+	try {
+		const serialized = {
+			name: error.name,
+			message: error.message
+		};
+		if (typeof error.stack === "string") serialized.stack = error.stack;
+		if ("cause" in error && error.cause !== void 0) serialized.cause = normalizeUnknown(error.cause, path);
+		for (const [key, value] of Object.entries(error)) {
+			if (key === "name" || key === "message" || key === "stack" || key === "cause") continue;
+			serialized[key] = normalizeUnknown(value, path);
+		}
+		return serialized;
+	} finally {
+		path.delete(error);
+	}
+}
+function getErrorStack(errorValue) {
+	if (!errorValue || typeof errorValue !== "object") return void 0;
+	const nestedStack = errorValue.stack;
+	return typeof nestedStack === "string" ? nestedStack : void 0;
+}
+
+//#endregion
+//#region src/observability/Telemetry.ts
+const invalidTraceId = "0".repeat(32);
+const invalidSpanId = "0".repeat(16);
+/**
+* Read active trace and span identifiers when a span is currently active.
+* @returns Active identifiers when available.
+*/
+function getActiveTraceIdentifiers() {
+	const activeSpan = trace.getActiveSpan();
+	if (!activeSpan) return {};
+	const spanContext = activeSpan.spanContext();
+	return getTraceIdentifiersFromContext(spanContext.traceId, spanContext.spanId);
+}
+/**
+* Build log-safe trace identifiers from OpenTelemetry span context values.
+* @param traceId - OpenTelemetry trace identifier.
+* @param spanId - OpenTelemetry span identifier.
+* @returns Trace identifiers when both ids are valid and non-noop.
+*/
+function getTraceIdentifiersFromContext(traceId, spanId) {
+	if (!isValidOtelIdentifier(traceId, invalidTraceId) || !isValidOtelIdentifier(spanId, invalidSpanId)) return {};
+	return {
+		trace_id: traceId,
+		span_id: spanId
+	};
+}
+/**
+* Build a logger that enriches each entry with shared telemetry context.
+* @param context - Static fields attached to every log entry.
+* @returns Context-aware logger.
+*/
+function getLoggerWithContext(context) {
+	const scopedLogger = getLogger();
+	const withContext = (logFn) => (entry) => logFn({
+		...context,
+		...getActiveTraceIdentifiers(),
+		...entry
+	});
+	return {
+		trace: withContext(scopedLogger.trace),
+		debug: withContext(scopedLogger.debug),
+		info: withContext(scopedLogger.info),
+		warn: withContext(scopedLogger.warn),
+		error: withContext(scopedLogger.error),
+		fatal: withContext(scopedLogger.fatal)
+	};
+}
+function isValidOtelIdentifier(identifier, invalidValue) {
+	return identifier.length === invalidValue.length && identifier !== invalidValue;
+}
 
 //#endregion
 //#region src/tracer/Tracer.ts
@@ -566,14 +764,18 @@ var utils_exports = /* @__PURE__ */ __exportAll({
 
 //#endregion
 //#region src/indexer/collectors/Admin.ts
-function create$21(parameters) {
+function create$22(parameters) {
 	const collector = "admin";
 	const { client, db, options: { maxBatchSize = 25, maxBlockNumber } = {} } = parameters;
 	const maxBlockNumberBI = maxBlockNumber !== void 0 ? BigInt(maxBlockNumber) : void 0;
 	let finalizedBlock = null;
 	let unfinalizedBlocks = [];
 	let initialized = false;
-	const logger = getLogger();
+	const logger = getLoggerWithContext({
+		component: "indexer.collector.admin",
+		collector,
+		chain_id: client.chain.id
+	});
 	let isMaxBlockNumberReached = false;
 	let tick = 0;
 	return { syncBlock: async () => {
@@ -593,9 +795,8 @@ function create$21(parameters) {
 			const { epoch, blockNumber: latestSavedBlockNumber } = await dbTx.blocks.getChain(client.chain.id);
 			if (maxBlockNumberBI !== void 0 && head.number >= maxBlockNumberBI) {
 				logger.info({
+					event: INDEXER_COLLECTOR_MAX_BLOCK_REACHED,
 					msg: `Head is greater than max block number`,
-					collector,
-					chainId: client.chain.id,
 					block_number: head.number,
 					max_block_number: maxBlockNumber
 				});
@@ -611,7 +812,6 @@ function create$21(parameters) {
 				tick,
 				client,
 				logger,
-				collector,
 				unfinalizedBlocks,
 				previousFinalizedBlock: finalizedBlock
 			});
@@ -622,7 +822,6 @@ function create$21(parameters) {
 				unfinalizedBlocks,
 				finalizedBlock,
 				logger,
-				collector,
 				maxBatchSize
 			});
 			unfinalizedBlocks = newUnfinalizedBlocks;
@@ -648,7 +847,7 @@ const commonAncestor = (block, unfinalizedBlocks) => {
 	return null;
 };
 const fetchFinalizedBlock = async (parameters) => {
-	let { tick, client, logger, collector, unfinalizedBlocks, previousFinalizedBlock } = parameters;
+	let { tick, client, logger, unfinalizedBlocks, previousFinalizedBlock } = parameters;
 	let finalizedBlock = previousFinalizedBlock;
 	if (tick % 20 === 0 || previousFinalizedBlock === null) {
 		finalizedBlock = await client.getBlock({
@@ -658,8 +857,7 @@ const fetchFinalizedBlock = async (parameters) => {
 		if (finalizedBlock === null || finalizedBlock.number === null) {
 			const msg = "Failed to get finalized block";
 			logger.fatal({
-				collector,
-				chainId: client.chain.id,
+				event: INDEXER_COLLECTOR_FINALIZED_BLOCK_FAILED,
 				msg
 			});
 			throw new Error(msg);
@@ -669,8 +867,7 @@ const fetchFinalizedBlock = async (parameters) => {
 	if (finalizedBlock.number === null || finalizedBlock.hash === null || finalizedBlock.parentHash === null) {
 		const msg = "Failed to get finalized block";
 		logger.fatal({
-			collector,
-			chainId: client.chain.id,
+			event: INDEXER_COLLECTOR_FINALIZED_BLOCK_FAILED,
 			msg
 		});
 		throw new Error(msg);
@@ -682,8 +879,7 @@ const fetchFinalizedBlock = async (parameters) => {
 	};
 };
 const reconcile = async (parameters) => {
-	let { client, block, unfinalizedBlocks, finalizedBlock, logger, collector, maxBatchSize } = parameters;
-	const chain = client.chain;
+	let { client, block, unfinalizedBlocks, finalizedBlock, logger, maxBatchSize } = parameters;
 	if (block.hash === null || block.number === null || block.parentHash === null) throw new Error("Failed to get block");
 	const latestBlock = unfinalizedBlocks[unfinalizedBlocks.length - 1];
 	if (latestBlock === void 0) {
@@ -707,9 +903,8 @@ const reconcile = async (parameters) => {
 	if (latestBlock.number >= block.number) {
 		const ancestor = commonAncestor(block, unfinalizedBlocks) || finalizedBlock;
 		logger.info({
+			event: INDEXER_COLLECTOR_REORG_DETECTED,
 			msg: `Reorg detected, latestBlock.number >= block.number`,
-			collector,
-			chain_id: chain.id,
 			ancestor: ancestor.number,
 			latest_block_number: latestBlock.number,
 			block_number: block.number
@@ -723,8 +918,7 @@ const reconcile = async (parameters) => {
 	}
 	if (latestBlock.number + 1n < block.number) {
 		logger.debug({
-			collector,
-			chain_id: chain.id,
+			event: INDEXER_COLLECTOR_MISSING_BLOCKS,
 			block_range: [latestBlock.number, block.number],
 			msg: `Missing blocks`
 		});
@@ -749,7 +943,6 @@ const reconcile = async (parameters) => {
 				unfinalizedBlocks,
 				finalizedBlock,
 				logger,
-				collector,
 				maxBatchSize
 			});
 			if (returnedBlock.number !== missingBlock.number) return {
@@ -764,16 +957,14 @@ const reconcile = async (parameters) => {
 			unfinalizedBlocks,
 			finalizedBlock,
 			logger,
-			collector,
 			maxBatchSize
 		});
 	}
 	if (block.parentHash !== latestBlock.hash) {
 		const ancestor = commonAncestor(block, unfinalizedBlocks) || finalizedBlock;
 		logger.info({
+			event: INDEXER_COLLECTOR_REORG_DETECTED,
 			msg: `Reorg detected, block parent hash !== latest block hash`,
-			collector,
-			chain_id: chain.id,
 			ancestor: ancestor.number,
 			latest_block_number: latestBlock.number,
 			block_number: block.number
@@ -806,31 +997,37 @@ const names = [
 	"positions",
 	"prices"
 ];
-function create$20({ name, collect, client, db, options }) {
-	const admin = create$21({
+function create$21({ name, collect, client, db, options }) {
+	const admin = create$22({
 		client,
 		db,
 		options
 	});
+	const chain = client.chain;
+	const interval = options.interval ?? 1e4;
 	return {
 		name,
-		chain: client.chain,
+		chain,
 		client,
 		db,
-		interval: options.interval ?? 1e4,
+		interval,
 		collect: async function* () {
 			const collector = name;
 			const chain = client.chain;
-			const logger = getLogger();
+			const logger = getLoggerWithContext({
+				component: "indexer.collector",
+				collector,
+				chain_id: chain.id
+			});
 			const collectorId = `${client.chain.id.toString()}.collector.${collector}`;
 			const tracer = getTracer(`router.${collectorId}`);
 			logger.info({
-				msg: `Collector started`,
-				collector,
-				chain_id: chain.id
+				event: INDEXER_COLLECTOR_STARTED,
+				msg: `Collector started`
 			});
 			let iterator = null;
 			let lastBlockNumber;
+			let retryAttempt = 0;
 			while (true) try {
 				if (iterator === null) iterator = await startActiveSpan(tracer, `${collectorId}.init`, async () => {
 					const { collector: collectorBlock } = await db.blocks.init({
@@ -859,20 +1056,36 @@ function create$20({ name, collect, client, db, options }) {
 						done
 					};
 				});
-				if (done) iterator = null;
-				else {
+				if (done) {
+					iterator = null;
+					retryAttempt = 0;
+				} else {
 					lastBlockNumber = blockNumber;
+					retryAttempt = 0;
 					yield blockNumber;
 				}
 			} catch (err) {
-				const isError = err instanceof Error;
+				const error = err instanceof Error ? err : new Error(String(err));
+				const invalidRange = getInvalidBlockRange(error);
+				if (invalidRange !== null) logger.warn({
+					event: INDEXER_COLLECTOR_RPC_QUERY_INVALID_RANGE,
+					msg: "Invalid eth_getLogs block range rejected",
+					rpc_method: "eth_getLogs",
+					action: "reset_iterator",
+					from_block: invalidRange.fromBlock,
+					to_block: invalidRange.toBlock
+				});
+				retryAttempt += 1;
+				const retryDelayMs = Math.min(interval, 1e3 * 2 ** Math.min(retryAttempt - 1, 3));
+				iterator = null;
 				logger.error({
+					event: INDEXER_COLLECTOR_FAILED,
 					msg: "Collector error",
-					collector,
-					chain_id: chain.id,
-					error: isError ? err.message : String(err),
-					stack: isError ? err.stack : void 0
+					err: error,
+					retry_attempt: retryAttempt,
+					retry_delay_ms: retryDelayMs
 				});
+				await wait(retryDelayMs);
 			}
 		}
 	};
@@ -884,7 +1097,11 @@ function create$20({ name, collect, client, db, options }) {
 function start(collector) {
 	let stopped = false;
 	const it = collector.collect();
-	const logger = getLogger();
+	const logger = getLoggerWithContext({
+		component: "indexer.collector",
+		collector: collector.name,
+		chain_id: collector.chain.id
+	});
 	const collectorId = `${collector.chain.id.toString()}.collector.${collector.name}`;
 	const tracer = getTracer(`router.${collectorId}`);
 	const blocks = collector.db.blocks;
@@ -918,9 +1135,8 @@ function start(collector) {
 		} catch (err) {
 			const error = err instanceof Error ? err : new Error(String(err));
 			logger.error({
+				event: INDEXER_COLLECTOR_POLL_FAILED,
 				msg: "Collector polling error",
-				collector: collector.name,
-				chain_id: collector.chain.id,
 				err: error
 			});
 		}
@@ -930,6 +1146,20 @@ function start(collector) {
 		stopped = true;
 	};
 }
+const getInvalidBlockRange = (error) => {
+	if (error.name !== "Chain.InvalidBlockRangeError") return null;
+	const candidate = error;
+	if (typeof candidate.fromBlock === "bigint" && typeof candidate.toBlock === "bigint") return {
+		fromBlock: candidate.fromBlock.toString(),
+		toBlock: candidate.toBlock.toString()
+	};
+	const match = error.message.match(/From block (\d+) to block (\d+)\./);
+	if (!match) return null;
+	return {
+		fromBlock: match[1],
+		toBlock: match[2]
+	};
+};
 
 //#endregion
 //#region src/core/Abi/MetaMorpho.ts
@@ -953,55 +1183,57 @@ const MetaMorphoFactory = parseAbi(["event CreateMetaMorpho(address indexed meta
 //#region src/core/Abi/MorphoV2.ts
 const MorphoV2 = parseAbi([
 	"constructor()",
-	"function collateralOf(bytes32 id, address user, address collateralToken) view returns (uint256)",
+	"function collateralOf(bytes20 id, address user, uint256 collateralIndex) view returns (uint128)",
 	"function consume(bytes32 group, uint256 amount)",
 	"function consumed(address user, bytes32 group) view returns (uint256)",
-	"function debtOf(bytes32 id, address user) view returns (uint256)",
+	"function debtOf(bytes20 id, address user) view returns (uint256)",
 	"function defaultFees(address loanToken, uint256 index) view returns (uint16)",
 	"function feeSetter() view returns (address)",
-	"function fees(bytes32 id) view returns (uint16[6])",
+	"function fees(bytes20 id) view returns (uint16[6])",
 	"function flashLoan(address token, uint256 assets, address callback, bytes data)",
-	"function isHealthy((address loanToken, (address token, uint256 lltv, address oracle)[] collaterals, uint256 maturity) obligation, bytes32 id, address borrower) view returns (bool)",
-	"function liquidate((address loanToken, (address token, uint256 lltv, address oracle)[] collaterals, uint256 maturity) obligation, (uint256 collateralIndex, uint256 repaid, uint256 seized)[] seizures, address borrower, bytes data) returns ((uint256 collateralIndex, uint256 repaid, uint256 seized)[])",
+	"function isHealthy((address loanToken, (address token, uint256 lltv, address oracle)[] collaterals, uint256 maturity, uint256 minCollatValue) obligation, bytes20 id, address borrower) view returns (bool)",
+	"function liquidate((address loanToken, (address token, uint256 lltv, address oracle)[] collaterals, uint256 maturity, uint256 minCollatValue) obligation, uint256 collateralIndex, uint256 seizedAssets, uint256 repaidUnits, address borrower, bytes data) returns (uint256, uint256)",
 	"function multicall(bytes[] calls)",
-	"function obligationCreated(bytes32 id) view returns (bool)",
-	"function obligationState(bytes32 id) view returns (uint128 totalUnits, uint128 totalShares, uint256 withdrawable, bool created)",
+	"function obligationCreated(bytes20 id) view returns (bool)",
+	"function obligationState(bytes20 id) view returns (uint128 totalUnits, uint128 totalShares, uint256 withdrawable, bool created, uint16[6] fees)",
 	"function owner() view returns (address)",
-	"function repay((address loanToken, (address token, uint256 lltv, address oracle)[] collaterals, uint256 maturity) obligation, uint256 obligationUnits, address onBehalf)",
+	"function repay((address loanToken, (address token, uint256 lltv, address oracle)[] collaterals, uint256 maturity, uint256 minCollatValue) obligation, uint256 obligationUnits, address onBehalf)",
 	"function session(address user) view returns (bytes32)",
 	"function setDefaultTradingFee(address loanToken, uint256 index, uint256 newTradingFee)",
 	"function setFeeSetter(address newFeeSetter)",
-	"function setObligationTradingFee(bytes32 id, uint256 index, uint256 newTradingFee)",
+	"function setObligationTradingFee(bytes20 id, uint256 index, uint256 newTradingFee)",
 	"function setOwner(address newOwner)",
 	"function setTradingFeeRecipient(address feeRecipient)",
-	"function sharesOf(bytes32 id, address user) view returns (uint256)",
+	"function sharesOf(bytes20 id, address user) view returns (uint256)",
 	"function shuffleSession()",
-	"function supplyCollateral((address loanToken, (address token, uint256 lltv, address oracle)[] collaterals, uint256 maturity) obligation, address collateral, uint256 assets, address onBehalf)",
-	"function take(uint256 buyerAssets, uint256 sellerAssets, uint256 obligationUnits, uint256 obligationShares, address taker, address takerCallback, bytes takerCallbackData, address receiverIfTakerIsSeller, ((address loanToken, (address token, uint256 lltv, address oracle)[] collaterals, uint256 maturity) obligation, bool buy, address maker, uint256 assets, uint256 obligationUnits, uint256 obligationShares, uint256 start, uint256 expiry, uint256 tick, bytes32 group, bytes32 session, address callback, bytes callbackData, address receiverIfMakerIsSeller) offer, (uint8 v, bytes32 r, bytes32 s) sig, bytes32 root, bytes32[] proof) returns (uint256, uint256, uint256, uint256)",
-	"function totalShares(bytes32 id) view returns (uint256)",
-	"function totalUnits(bytes32 id) view returns (uint256)",
-	"function touchObligation((address loanToken, (address token, uint256 lltv, address oracle)[] collaterals, uint256 maturity) obligation) returns (bytes32)",
-	"function tradingFee(bytes32 id, uint256 timeToMaturity) view returns (uint256)",
+	"function supplyCollateral((address loanToken, (address token, uint256 lltv, address oracle)[] collaterals, uint256 maturity, uint256 minCollatValue) obligation, uint256 collateralIndex, uint256 assets, address onBehalf)",
+	"function take(uint256 buyerAssets, uint256 sellerAssets, uint256 obligationUnits, uint256 obligationShares, address taker, address takerCallback, bytes takerCallbackData, address receiverIfTakerIsSeller, ((address loanToken, (address token, uint256 lltv, address oracle)[] collaterals, uint256 maturity, uint256 minCollatValue) obligation, bool buy, address maker, uint256 assets, uint256 obligationUnits, uint256 obligationShares, uint256 start, uint256 expiry, uint256 tick, bytes32 group, bytes32 session, address callback, bytes callbackData, address receiverIfMakerIsSeller) offer, (uint8 v, bytes32 r, bytes32 s) sig, bytes32 root, bytes32[] proof) returns (uint256, uint256, uint256, uint256)",
+	"function toId((address loanToken, (address token, uint256 lltv, address oracle)[] collaterals, uint256 maturity, uint256 minCollatValue) obligation) view returns (bytes20)",
+	"function toObligation(bytes20 id) view returns ((address loanToken, (address token, uint256 lltv, address oracle)[] collaterals, uint256 maturity, uint256 minCollatValue))",
+	"function totalShares(bytes20 id) view returns (uint256)",
+	"function totalUnits(bytes20 id) view returns (uint256)",
+	"function touchObligation((address loanToken, (address token, uint256 lltv, address oracle)[] collaterals, uint256 maturity, uint256 minCollatValue) obligation) returns (bytes20)",
+	"function tradingFee(bytes20 id, uint256 timeToMaturity) view returns (uint256)",
 	"function tradingFeeRecipient() view returns (address)",
-	"function withdraw((address loanToken, (address token, uint256 lltv, address oracle)[] collaterals, uint256 maturity) obligation, uint256 obligationUnits, uint256 shares, address onBehalf, address receiver) returns (uint256, uint256)",
-	"function withdrawCollateral((address loanToken, (address token, uint256 lltv, address oracle)[] collaterals, uint256 maturity) obligation, address collateral, uint256 assets, address onBehalf, address receiver)",
-	"function withdrawable(bytes32 id) view returns (uint256)",
+	"function withdraw((address loanToken, (address token, uint256 lltv, address oracle)[] collaterals, uint256 maturity, uint256 minCollatValue) obligation, uint256 obligationUnits, uint256 shares, address onBehalf, address receiver) returns (uint256, uint256)",
+	"function withdrawCollateral((address loanToken, (address token, uint256 lltv, address oracle)[] collaterals, uint256 maturity, uint256 minCollatValue) obligation, uint256 collateralIndex, uint256 assets, address onBehalf, address receiver)",
+	"function withdrawable(bytes20 id) view returns (uint256)",
 	"event Constructor(address indexed owner)",
 	"event Consume(address indexed user, bytes32 indexed group, uint256 amount)",
 	"event FlashLoan(address indexed caller, address indexed token, uint256 assets)",
-	"event Liquidate(address indexed caller, bytes32 indexed id, (uint256 collateralIndex, uint256 repaid, uint256 seized)[] seizures, address indexed borrower, uint256 totalRepaid, uint256 badDebt)",
-	"event ObligationCreated(bytes32 indexed id, (address loanToken, (address token, uint256 lltv, address oracle)[] collaterals, uint256 maturity) obligation)",
-	"event Repay(address indexed caller, bytes32 indexed id, uint256 obligationUnits, address indexed onBehalf)",
+	"event Liquidate(address indexed caller, bytes20 indexed id_, uint256 collateralIndex, uint256 seizedAssets, uint256 repaidUnits, address indexed borrower, uint256 badDebt)",
+	"event ObligationCreated(bytes20 indexed id_, (address loanToken, (address token, uint256 lltv, address oracle)[] collaterals, uint256 maturity, uint256 minCollatValue) obligation)",
+	"event Repay(address indexed caller, bytes20 indexed id_, uint256 obligationUnits, address indexed onBehalf)",
 	"event SetDefaultTradingFee(address indexed loanToken, uint256 indexed index, uint256 newTradingFee)",
 	"event SetFeeSetter(address indexed feeSetter)",
-	"event SetObligationTradingFee(bytes32 indexed id, uint256 indexed index, uint256 newTradingFee)",
+	"event SetObligationTradingFee(bytes20 indexed id_, uint256 indexed index, uint256 newTradingFee)",
 	"event SetOwner(address indexed owner)",
 	"event SetTradingFeeRecipient(address indexed feeRecipient)",
 	"event ShuffleSession(address indexed user, bytes32 session)",
-	"event SupplyCollateral(address caller, bytes32 indexed id, address indexed collateral, uint256 assets, address indexed onBehalf)",
-	"event Take(address caller, bytes32 indexed id, address indexed maker, address indexed taker, bool offerIsBuy, uint256 buyerAssets, uint256 sellerAssets, uint256 obligationUnits, uint256 obligationShares, bool buyerIsLender, bool sellerIsBorrower, address sellerReceiver, bytes32 group, uint256 consumed)",
-	"event Withdraw(address caller, bytes32 indexed id, uint256 obligationUnits, uint256 shares, address indexed onBehalf, address indexed receiver)",
-	"event WithdrawCollateral(address caller, bytes32 indexed id, address indexed collateral, uint256 assets, address indexed onBehalf, address receiver)"
+	"event SupplyCollateral(address caller, bytes20 indexed id_, address indexed collateral, uint256 assets, address indexed onBehalf)",
+	"event Take(address caller, bytes20 indexed id_, address indexed maker, address indexed taker, bool offerIsBuy, uint256 buyerAssets, uint256 sellerAssets, uint256 obligationUnits, uint256 obligationShares, bool buyerIsLender, bool sellerIsBorrower, address sellerReceiver, bytes32 group, uint256 consumed)",
+	"event Withdraw(address caller, bytes20 indexed id_, uint256 obligationUnits, uint256 shares, address indexed onBehalf, address indexed receiver)",
+	"event WithdrawCollateral(address caller, bytes20 indexed id_, address indexed collateral, uint256 assets, address indexed onBehalf, address receiver)"
 ]);
 
 //#endregion
@@ -1159,6 +1391,7 @@ const Morpho = [
 //#endregion
 //#region src/core/Callback.ts
 var Callback_exports = /* @__PURE__ */ __exportAll({
+	CallbackType: () => CallbackType,
 	Type: () => Type$1,
 	isEmptyCallback: () => isEmptyCallback
 });
@@ -1167,6 +1400,10 @@ let Type$1 = /* @__PURE__ */ function(Type) {
 	Type["SellWithEmptyCallback"] = "sell_with_empty_callback";
 	return Type;
 }({});
+let CallbackType = /* @__PURE__ */ function(CallbackType) {
+	CallbackType["Empty"] = "empty";
+	return CallbackType;
+}({});
 const isEmptyCallback = (offer) => offer.callback.data === "0x";
 
 //#endregion
@@ -1177,6 +1414,7 @@ var Chain_exports = /* @__PURE__ */ __exportAll({
 	InvalidBlockRangeError: () => InvalidBlockRangeError,
 	InvalidBlockWindowError: () => InvalidBlockWindowError,
 	MissingBlockNumberError: () => MissingBlockNumberError,
+	UnrecoverableLogsResponseSizeError: () => UnrecoverableLogsResponseSizeError,
 	chainIds: () => chainIds,
 	chainNames: () => chainNames,
 	chains: () => chains$1,
@@ -1243,8 +1481,8 @@ const chains$1 = {
 		name: "base",
 		custom: {
 			morpho: {
-				address: "0x3F067BC9D8898F6ec02D6480c3fF1026E512BcBF",
-				blockCreated: 41799989
+				address: "0x4C752Cdc4b13c9A6a933CbecfE050eC0BA0B45f9",
+				blockCreated: 42365274
 			},
 			morphoBlue: {
 				address: "0xBBBBBbbBBb9cC5e90e3b3Af64bdAF62C37EEFFCb",
@@ -1273,8 +1511,8 @@ const chains$1 = {
 		name: "ethereum-virtual-testnet",
 		custom: {
 			morpho: {
-				address: "0xc9f3c65996fc46b9500608b2c9a9152c01c540f7",
-				blockCreated: 23226871
+				address: "0x9ac49a344376964291f7289663beb78e2952de44",
+				blockCreated: 23229385
 			},
 			morphoBlue: {
 				address: "0xBBBBBbbBBb9cC5e90e3b3Af64bdAF62C37EEFFCb",
@@ -1332,33 +1570,72 @@ const MAX_BATCH_SIZE = 1e4;
 const DEFAULT_BATCH_SIZE$2 = 2500;
 const MAX_BLOCK_WINDOW = 1e4;
 const DEFAULT_BLOCK_WINDOW = 8e3;
+const MIN_BLOCK_WINDOW = 0n;
+const oversizedLogsErrorPatterns = [
+	"cannot create a string longer than",
+	"response is too big",
+	"response size exceeded",
+	"log response size exceeded",
+	"query returned more than",
+	"too many results"
+];
+const getLatestBlockNumber = async (client) => {
+	return await getBlockNumber(client, { cacheTime: 0 });
+};
 async function* streamLogs(parameters) {
 	const { client, contractAddress, event, blockNumberGte, blockNumberLte, order = "desc", options: { maxBatchSize = DEFAULT_BATCH_SIZE$2, blockWindow = DEFAULT_BLOCK_WINDOW } = {} } = parameters;
 	if (maxBatchSize > MAX_BATCH_SIZE) throw new InvalidBatchSizeError(maxBatchSize);
 	if (blockWindow > MAX_BLOCK_WINDOW) throw new InvalidBlockWindowError(blockWindow);
 	if (order === "asc" && blockNumberGte === void 0) throw new MissingBlockNumberError();
-	const latestBlock = (await getBlock(client, {
-		blockTag: "latest",
-		includeTransactions: false
-	})).number;
+	const ascendingLowerBound = order === "asc" ? BigInt(blockNumberGte) : void 0;
+	const latestBlock = await getLatestBlockNumber(client);
+	let upperBound = blockNumberLte === void 0 ? latestBlock : min(BigInt(blockNumberLte), latestBlock);
+	const lowerBound = BigInt(blockNumberGte || 0);
+	const configuredBlockWindow = BigInt(blockWindow);
+	let adaptiveBlockWindow = configuredBlockWindow;
 	let toBlock = 0n;
-	if (order === "asc") toBlock = min(BigInt(blockNumberGte) + BigInt(blockWindow), blockNumberLte ? BigInt(blockNumberLte) : latestBlock);
-	if (order === "desc") toBlock = blockNumberLte === void 0 ? latestBlock : min(BigInt(blockNumberLte), latestBlock);
+	if (order === "asc") toBlock = min(ascendingLowerBound + adaptiveBlockWindow, upperBound);
+	if (order === "desc") toBlock = upperBound;
 	let fromBlock = 0n;
-	if (order === "asc") fromBlock = min(BigInt(blockNumberGte), latestBlock);
-	if (order === "desc") fromBlock = max$1(BigInt(blockNumberGte || toBlock - BigInt(blockWindow)), 0n);
-	if (order === "asc") toBlock = min(toBlock, fromBlock + BigInt(blockWindow));
-	if (order === "desc") fromBlock = max$1(fromBlock, toBlock - BigInt(blockWindow));
+	if (order === "asc") fromBlock = ascendingLowerBound;
+	if (order === "desc") fromBlock = max$1(BigInt(blockNumberGte || toBlock - adaptiveBlockWindow), 0n);
+	if (order === "asc") toBlock = min(toBlock, fromBlock + adaptiveBlockWindow);
+	if (order === "desc") fromBlock = max$1(fromBlock, toBlock - adaptiveBlockWindow);
 	if (fromBlock > toBlock) throw new InvalidBlockRangeError(fromBlock, toBlock);
 	let streaming = true;
 	while (streaming) {
-		const logs = await getLogs(client, {
-			address: contractAddress,
-			event,
-			fromBlock,
-			toBlock
-		});
-		streaming = order === "asc" ? toBlock < (blockNumberLte || latestBlock) : fromBlock > (blockNumberGte || 0n);
+		let logs;
+		try {
+			logs = await getLogs(client, {
+				address: contractAddress,
+				event,
+				fromBlock,
+				toBlock
+			});
+		} catch (err) {
+			if (order === "asc" && isBlockOutOfRangeError(err)) {
+				const previousUpperBound = upperBound;
+				const previousFromBlock = fromBlock;
+				const previousToBlock = toBlock;
+				const latestBlockOnRetry = await getLatestBlockNumber(client);
+				upperBound = min(upperBound, latestBlockOnRetry);
+				if (upperBound < ascendingLowerBound) throw new InvalidBlockRangeError(ascendingLowerBound, upperBound);
+				toBlock = min(toBlock, upperBound);
+				fromBlock = max$1(min(fromBlock, upperBound), ascendingLowerBound);
+				if (fromBlock > toBlock) throw new InvalidBlockRangeError(fromBlock, toBlock);
+				if (!(upperBound < previousUpperBound || fromBlock < previousFromBlock || toBlock < previousToBlock)) throw err;
+				continue;
+			}
+			if (isOversizedLogsError(err)) {
+				if (fromBlock === toBlock) throw new UnrecoverableLogsResponseSizeError(fromBlock, err);
+				adaptiveBlockWindow = max$1((toBlock - fromBlock) / 2n, MIN_BLOCK_WINDOW);
+				if (order === "asc") toBlock = min(fromBlock + adaptiveBlockWindow, upperBound);
+				else fromBlock = max$1(toBlock - adaptiveBlockWindow, lowerBound);
+				continue;
+			}
+			throw err;
+		}
+		streaming = order === "asc" ? toBlock < upperBound : fromBlock > lowerBound;
 		if (logs.length === 0 && !streaming) break;
 		if (logs.length === 0 && streaming) yield {
 			logs: [],
@@ -1373,17 +1650,19 @@ async function* streamLogs(parameters) {
 			logs: logBatch,
 			blockNumber: logBatch.length === maxBatchSize ? Number(logBatch[logBatch.length - 1]?.blockNumber) : order === "asc" ? Number(toBlock) : Number(fromBlock)
 		};
+		if (adaptiveBlockWindow < configuredBlockWindow) {
+			const expandedBlockWindow = adaptiveBlockWindow === 0n ? 1n : adaptiveBlockWindow * 2n;
+			adaptiveBlockWindow = min(expandedBlockWindow, configuredBlockWindow);
+		}
 		if (order === "asc") {
-			const upperBound = BigInt(blockNumberLte || latestBlock);
 			const nextFromBlock = min(BigInt(toBlock) + 1n, upperBound);
-			const nextToBlock = min(toBlock + BigInt(blockWindow) + 1n, upperBound);
+			const nextToBlock = min(toBlock + adaptiveBlockWindow + 1n, upperBound);
 			fromBlock = nextFromBlock;
 			toBlock = nextToBlock;
 		}
 		if (order === "desc") {
-			const lowerBound = BigInt(blockNumberGte || 0);
 			const nextToBlock = max$1(fromBlock - 1n, lowerBound);
-			const nextFromBlock = max$1(fromBlock - BigInt(blockWindow) - 1n, lowerBound);
+			const nextFromBlock = max$1(fromBlock - adaptiveBlockWindow - 1n, lowerBound);
 			toBlock = nextToBlock;
 			fromBlock = nextFromBlock;
 		}
@@ -1393,10 +1672,23 @@ async function* streamLogs(parameters) {
 		blockNumber: order === "asc" ? Number(toBlock) : Number(fromBlock)
 	};
 }
+const isBlockOutOfRangeError = (error) => {
+	let cause = error;
+	while (cause && typeof cause === "object") {
+		const candidate = cause;
+		if (typeof candidate.message === "string" && candidate.message.includes("BlockOutOfRangeError") || typeof candidate.details === "string" && candidate.details.includes("BlockOutOfRangeError")) return true;
+		cause = candidate.cause;
+	}
+	return false;
+};
 var InvalidBlockRangeError = class extends BaseError {
 	name = "Chain.InvalidBlockRangeError";
+	fromBlock;
+	toBlock;
 	constructor(fromBlock, toBlock) {
 		super(`Invalid block range while streaming data from chain. From block ${fromBlock} to block ${toBlock}.`);
+		this.fromBlock = fromBlock;
+		this.toBlock = toBlock;
 	}
 };
 var InvalidBlockWindowError = class extends BaseError {
@@ -1417,16 +1709,35 @@ var MissingBlockNumberError = class extends BaseError {
 		super("Missing block number when streaming data from chain in ascending order.");
 	}
 };
+var UnrecoverableLogsResponseSizeError = class extends BaseError {
+	name = "Chain.UnrecoverableLogsResponseSizeError";
+	constructor(blockNumber, cause) {
+		const rootCause = cause instanceof Error ? cause : cause === void 0 ? void 0 : new Error(String(cause));
+		super(`Failed to stream logs because even a single-block query exceeded the RPC response size limit at block ${blockNumber}.`, { cause: rootCause });
+	}
+};
+function isOversizedLogsError(err) {
+	return oversizedLogsErrorPatterns.some((pattern) => collectErrorMessages(err).includes(pattern));
+}
+function collectErrorMessages(err) {
+	if (!(err instanceof Error)) return "";
+	const fragments = [err.message];
+	const candidate = err;
+	if (typeof candidate.details === "string") fragments.push(candidate.details);
+	if (typeof candidate.shortMessage === "string") fragments.push(candidate.shortMessage);
+	if (candidate.cause instanceof Error) fragments.push(collectErrorMessages(candidate.cause));
+	return fragments.join(" ").toLowerCase();
+}
 
 //#endregion
 //#region src/core/ChainRegistry.ts
-var ChainRegistry_exports = /* @__PURE__ */ __exportAll({ create: () => create$19 });
+var ChainRegistry_exports = /* @__PURE__ */ __exportAll({ create: () => create$20 });
 /**
 * Creates a chain registry from a list of chains.
 * @param chains - Array of chain objects to register.
 * @returns A registry for looking up chains by ID. {@link ChainRegistry}
 */
-function create$19(chains) {
+function create$20(chains) {
 	const byId = /* @__PURE__ */ new Map();
 	for (const chain of chains) byId.set(chain.id, chain);
 	return {
@@ -1717,9 +2028,9 @@ const MaturitySchema = z$1.number().int().refine((maturity) => {
 	}
 }, { error: (issue) => {
 	try {
-		return `The maturity is set to ${/* @__PURE__ */ new Date(issue.input * 1e3)}. It must fall on the allowed settlement cycles (Friday 15:00 UTC at the end of week/month/quarter).`;
+		return `The maturity is set to ${/* @__PURE__ */ new Date(issue.input * 1e3)}. It must be at 15:00:00 UTC.`;
 	} catch (_) {
-		return `The maturity is set to ${issue.input}. It must fall on the allowed settlement cycles (Friday 15:00 UTC at the end of week/month/quarter).`;
+		return `The maturity is set to ${issue.input}. It must be at 15:00:00 UTC.`;
 	}
 } }).transform((maturity) => maturity);
 let MaturityType = /* @__PURE__ */ function(MaturityType) {
@@ -1751,9 +2062,14 @@ function from$16(ts) {
 		throw new InvalidOptionError(ts);
 	}
 	if (typeof ts === "number" && ts > 0xe8d4a51000) throw new InvalidFormatError();
-	if (!Object.values(MaturityOptions).some((option) => option() === ts)) throw new InvalidDateError(ts);
+	if (!isAt15UTC(ts)) throw new InvalidDateError(ts);
 	return ts;
 }
+/** Checks whether a timestamp (in seconds) falls at exactly 15:00:00 UTC. */
+function isAt15UTC(ts) {
+	const date = /* @__PURE__ */ new Date(ts * 1e3);
+	return date.getUTCHours() === 15 && date.getUTCMinutes() === 0 && date.getUTCSeconds() === 0 && date.getUTCMilliseconds() === 0;
+}
 /** Returns the end of the current week (friday at 15:00:00 UTC) */
 const endOfWeek = () => fridayOfWeek(0);
 /** Returns the end of the next week (friday at 15:00:00 UTC) */
@@ -1814,7 +2130,7 @@ var InvalidFormatError = class extends BaseError {
 var InvalidDateError = class extends BaseError {
 	name = "Maturity.InvalidDateError";
 	constructor(input) {
-		super(`Invalid maturity date. Input: "${input}". Accepted values are: ${Object.values(MaturityOptions).map((option) => `"${option()}"`).join(", ")}.`);
+		super(`Invalid maturity date. Input: "${input}". Maturity must be at 15:00:00 UTC.`);
 	}
 };
 var InvalidOptionError = class extends BaseError {
@@ -1841,7 +2157,8 @@ var Obligation_exports = /* @__PURE__ */ __exportAll({
 const ObligationSchema = z$1.object({
 	loanToken: z$1.string().transform(transformAddress),
 	collaterals: CollateralsSchema,
-	maturity: MaturitySchema
+	maturity: MaturitySchema,
+	minCollatValue: z$1.bigint({ coerce: true }).min(0n).optional().default(0n)
 });
 const abi = [
 	{
@@ -1856,6 +2173,10 @@ const abi = [
 	{
 		type: "uint256",
 		name: "maturity"
+	},
+	{
+		type: "uint256",
+		name: "minCollatValue"
 	}
 ];
 const tupleAbi = [{
@@ -1893,7 +2214,8 @@ function from$15(parameters) {
 		return {
 			loanToken: parsedObligation.loanToken.toLowerCase(),
 			collaterals: parsedObligation.collaterals.sort((a, b) => a.asset.localeCompare(b.asset)),
-			maturity: parsedObligation.maturity
+			maturity: parsedObligation.maturity,
+			minCollatValue: parsedObligation.minCollatValue
 		};
 	} catch (error) {
 		throw new InvalidObligationError(error);
@@ -1910,7 +2232,8 @@ function fromSnakeCase$2(input) {
 }
 /**
 * Calculates a canonical key for an obligation payload.
-* The key is computed as keccak256(abi.encode(loanToken, collaterals, maturity)).
+* The key is computed as keccak256(abi.encode(loanToken, collaterals, maturity, minCollatValue)).
+* If omitted, `minCollatValue` defaults to `0`.
 * @throws If the collaterals are not sorted alphabetically by address. {@link CollateralsAreNotSortedError}
 * @param parameters - {@link key.Parameters}
 * @returns The obligation key as a 32-byte hex string. {@link key.ReturnType}
@@ -1936,7 +2259,8 @@ function key(parameters) {
 			lltv: c.lltv,
 			oracle: c.oracle.toLowerCase()
 		})),
-		BigInt(parameters.maturity)
+		BigInt(parameters.maturity),
+		parameters.minCollatValue ?? 0n
 	]));
 }
 /**
@@ -1988,39 +2312,42 @@ var Id_exports = /* @__PURE__ */ __exportAll({
 	creationCode: () => creationCode,
 	toId: () => toId
 });
-const CREATION_CODE_PREFIX = "0x603f380380603f5f395ff3";
+const CREATION_CODE_PREFIX = "0x600b380380600b5f395ff3";
 /**
 * Builds the same creation code as `IdLib.creationCode` in Solidity.
 *
-* Layout: `prefix (11 bytes) + chainId (32 bytes) + morphoV2 (20 bytes) + abi.encode(obligation)`.
+* Layout: `prefix (11 bytes) + abi.encode(obligation)`.
 *
 * @param parameters - {@link creationCode.Parameters}
 * @returns The CREATE2 init code bytes. {@link creationCode.ReturnType}
 */
 function creationCode(parameters) {
-	const encodedObligation = encodeAbiParameters(tupleAbi, [{
+	return concatHex([CREATION_CODE_PREFIX, encodeAbiParameters(tupleAbi, [{
 		loanToken: parameters.obligation.loanToken.toLowerCase(),
 		collaterals: parameters.obligation.collaterals.map((collateral) => ({
 			token: collateral.asset.toLowerCase(),
 			lltv: collateral.lltv,
 			oracle: collateral.oracle.toLowerCase()
 		})),
-		maturity: BigInt(parameters.obligation.maturity)
-	}]);
-	return concatHex([
-		CREATION_CODE_PREFIX,
-		numberToHex(BigInt(parameters.chainId), { size: 32 }),
-		parameters.morphoV2.toLowerCase(),
-		encodedObligation
-	]);
+		maturity: BigInt(parameters.obligation.maturity),
+		minCollatValue: 0n
+	}])]);
 }
 /**
-* Computes the same id as `IdLib.toId` in Solidity.
+* Computes the same id as `IdLib.toId` in Solidity using the CREATE2 preimage:
+* `keccak256(0xff ++ morphoV2 ++ chainId ++ keccak256(creationCode))`,
+* then truncates to the lower 20 bytes.
+*
 * @param parameters - {@link toId.Parameters}
 * @returns The obligation id. {@link toId.ReturnType}
 */
 function toId(parameters) {
-	return keccak256(creationCode(parameters));
+	return `0x${keccak256(concatHex([
+		"0xff",
+		parameters.morphoV2.toLowerCase(),
+		numberToHex(BigInt(parameters.chainId), { size: 32 }),
+		keccak256(creationCode(parameters))
+	])).slice(-40)}`;
 }
 
 //#endregion
@@ -2317,7 +2644,7 @@ function hash(offer) {
 * The id is computed with {@link Id.toId}.
 * @param offer - The offer to calculate the obligation id for.
 * @param parameters - The chain context used by the onchain id function.
-* @returns The obligation id as a 32-byte hex string.
+* @returns The obligation id as a 20-byte hex string.
 */
 function obligationId(offer, parameters) {
 	return toId({
@@ -2480,10 +2807,10 @@ const takeEvent = {
 			internalType: "address"
 		},
 		{
-			name: "id",
-			type: "bytes32",
+			name: "id_",
+			type: "bytes20",
 			indexed: true,
-			internalType: "bytes32"
+			internalType: "bytes20"
 		},
 		{
 			name: "maker",
@@ -2602,10 +2929,10 @@ const repayEvent = {
 			internalType: "address"
 		},
 		{
-			name: "id",
-			type: "bytes32",
+			name: "id_",
+			type: "bytes20",
 			indexed: true,
-			internalType: "bytes32"
+			internalType: "bytes20"
 		},
 		{
 			name: "obligationUnits",
@@ -2636,46 +2963,35 @@ const liquidateEvent = {
 			internalType: "address"
 		},
 		{
-			name: "id",
-			type: "bytes32",
+			name: "id_",
+			type: "bytes20",
 			indexed: true,
-			internalType: "bytes32"
+			internalType: "bytes20"
 		},
 		{
-			name: "seizures",
-			type: "tuple[]",
+			name: "collateralIndex",
+			type: "uint256",
 			indexed: false,
-			internalType: "struct IMorphoV2.Seizure[]",
-			components: [
-				{
-					name: "collateralIndex",
-					type: "uint256",
-					internalType: "uint256"
-				},
-				{
-					name: "repaid",
-					type: "uint256",
-					internalType: "uint256"
-				},
-				{
-					name: "seized",
-					type: "uint256",
-					internalType: "uint256"
-				}
-			]
+			internalType: "uint256"
 		},
 		{
-			name: "borrower",
-			type: "address",
-			indexed: true,
-			internalType: "address"
+			name: "seizedAssets",
+			type: "uint256",
+			indexed: false,
+			internalType: "uint256"
 		},
 		{
-			name: "totalRepaid",
+			name: "repaidUnits",
 			type: "uint256",
 			indexed: false,
 			internalType: "uint256"
 		},
+		{
+			name: "borrower",
+			type: "address",
+			indexed: true,
+			internalType: "address"
+		},
 		{
 			name: "badDebt",
 			type: "uint256",
@@ -2699,10 +3015,10 @@ const supplyCollateralEvent = {
 			internalType: "address"
 		},
 		{
-			name: "id",
-			type: "bytes32",
+			name: "id_",
+			type: "bytes20",
 			indexed: true,
-			internalType: "bytes32"
+			internalType: "bytes20"
 		},
 		{
 			name: "collateral",
@@ -2739,10 +3055,10 @@ const withdrawCollateralEvent = {
 			internalType: "address"
 		},
 		{
-			name: "id",
-			type: "bytes32",
+			name: "id_",
+			type: "bytes20",
 			indexed: true,
-			internalType: "bytes32"
+			internalType: "bytes20"
 		},
 		{
 			name: "collateral",
@@ -3587,11 +3903,12 @@ const BrandTypeId = Symbol.for("mempool/Brand");
 
 //#endregion
 //#region src/database/drizzle/VERSION.ts
-const VERSION = "router_v1.11";
+const VERSION = "router_v1.13";
 
 //#endregion
 //#region src/database/drizzle/schema.ts
 var schema_exports = /* @__PURE__ */ __exportAll({
+	CallbackTypes: () => CallbackTypes,
 	PositionTypes: () => PositionTypes,
 	StatusCode: () => StatusCode,
 	TABLE_NAMES: () => TABLE_NAMES,
@@ -3649,7 +3966,7 @@ const obligations = s.table(EnumTableName.OBLIGATIONS, {
 	maturity: integer("maturity").notNull()
 });
 const obligationIdKeys = s.table(EnumTableName.OBLIGATION_ID_KEYS, {
-	obligationId: varchar("obligation_id", { length: 66 }).primaryKey(),
+	obligationId: varchar("obligation_id", { length: 42 }).primaryKey(),
 	obligationKey: varchar("obligation_key", { length: 66 }).notNull().references(() => obligations.obligationKey, { onDelete: "cascade" }),
 	chainId: bigint("chain_id", { mode: "number" }).$type().notNull(),
 	morphoV2: varchar("morpho_v2", { length: 42 }).notNull()
@@ -3730,7 +4047,7 @@ const oracles$1 = s.table(EnumTableName.ORACLES, {
 })]);
 const offers = s.table(EnumTableName.OFFERS, {
 	hash: varchar("hash", { length: 66 }).notNull(),
-	obligationId: varchar("obligation_id", { length: 66 }).notNull().references(() => obligationIdKeys.obligationId, { onDelete: "cascade" }),
+	obligationId: varchar("obligation_id", { length: 42 }).notNull().references(() => obligationIdKeys.obligationId, { onDelete: "cascade" }),
 	assets: numeric("assets", {
 		precision: 78,
 		scale: 0
@@ -3781,7 +4098,7 @@ const offers = s.table(EnumTableName.OFFERS, {
 ]);
 const offersCallbacks = s.table(EnumTableName.OFFERS_CALLBACKS, {
 	offerHash: varchar("offer_hash", { length: 66 }).notNull(),
-	obligationId: varchar("obligation_id", { length: 66 }).notNull(),
+	obligationId: varchar("obligation_id", { length: 42 }).notNull(),
 	callbackId: varchar("callback_id", { length: 66 })
 }, (table) => [foreignKey({
 	columns: [table.offerHash, table.obligationId],
@@ -3795,20 +4112,18 @@ const offersCallbacks = s.table(EnumTableName.OFFERS_CALLBACKS, {
 	],
 	name: "offers_callbacks_pk"
 })]);
+const CallbackTypes = s.enum("callback_type", Object.values(CallbackType));
 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(),
+	positionContract: varchar("position_contract", { length: 66 }).notNull(),
 	positionUser: varchar("position_user", { length: 42 }).notNull(),
 	positionTypeId: integer("position_type_id").notNull().references(() => positionTypes.id, { onDelete: "no action" }),
-	amount: numeric("amount", {
-		precision: 78,
-		scale: 0
-	})
+	type: CallbackTypes("type").notNull()
 });
 const lotsPositions = s.table(EnumTableName.LOTS_POSITIONS, {
 	chainId: bigint("chain_id", { mode: "number" }).$type().notNull(),
-	contract: varchar("contract", { length: 42 }).notNull(),
+	contract: varchar("contract", { length: 66 }).notNull(),
 	user: varchar("user", { length: 42 }).notNull(),
 	positionTypeId: integer("position_type_id").notNull().references(() => positionTypes.id, { onDelete: "no action" })
 }, (table) => [primaryKey({
@@ -3822,9 +4137,9 @@ const lotsPositions = s.table(EnumTableName.LOTS_POSITIONS, {
 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(),
+	contract: varchar("contract", { length: 66 }).notNull(),
 	group: varchar("group", { length: 66 }).notNull(),
-	obligationId: varchar("obligation_id", { length: 66 }).notNull(),
+	obligationId: varchar("obligation_id", { length: 42 }).notNull(),
 	lower: numeric("lower", {
 		precision: 78,
 		scale: 0
@@ -3874,9 +4189,9 @@ const lots = s.table(EnumTableName.LOTS, {
 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(),
+	contract: varchar("contract", { length: 66 }).notNull(),
 	group: varchar("group", { length: 66 }).notNull(),
-	obligationId: varchar("obligation_id", { length: 66 }).notNull(),
+	obligationId: varchar("obligation_id", { length: 42 }).notNull(),
 	value: numeric("value", {
 		precision: 78,
 		scale: 0
@@ -3989,7 +4304,7 @@ const status = s.table("status", {
 });
 const validations = s.table("validations", {
 	offerHash: varchar("offer_hash", { length: 66 }).notNull(),
-	obligationId: varchar("obligation_id", { length: 66 }).notNull(),
+	obligationId: varchar("obligation_id", { length: 42 }).notNull(),
 	statusId: integer("status_id").notNull().references(() => status.id, { onDelete: "no action" }),
 	updatedAt: timestamp("updated_at").defaultNow().notNull()
 }, (table) => [primaryKey({
@@ -4026,7 +4341,7 @@ const trees = s.table(EnumTableName.TREES, {
 });
 const merklePaths = s.table(EnumTableName.MERKLE_PATHS, {
 	offerHash: varchar("offer_hash", { length: 66 }).notNull(),
-	obligationId: varchar("obligation_id", { length: 66 }).notNull(),
+	obligationId: varchar("obligation_id", { length: 42 }).notNull(),
 	treeRoot: varchar("tree_root", { length: 66 }).notNull().references(() => trees.root, { onDelete: "cascade" }),
 	proofNodes: text("proof_nodes").notNull(),
 	createdAt: timestamp("created_at").defaultNow().notNull()
@@ -4043,6 +4358,54 @@ const merklePaths = s.table(EnumTableName.MERKLE_PATHS, {
 	index("merkle_paths_tree_root_idx").on(table.treeRoot)
 ]);
 
+//#endregion
+//#region src/indexer/collectors/CollectFunctions/IndexedEventTelemetry.ts
+/**
+* Resolve the chain head block metadata used by indexed collector telemetry events.
+* @param parameters - Block lookup parameters.
+* @returns Head block number and timestamp (seconds since epoch).
+*/
+async function getIndexedEventHeadContext(parameters) {
+	const { client, headBlockNumber } = parameters;
+	const fallbackHeadTimestampS = Math.floor(Date.now() / 1e3);
+	const getBlock = client.getBlock;
+	if (typeof getBlock !== "function") return {
+		head_block_number: headBlockNumber,
+		head_block_timestamp_s: fallbackHeadTimestampS
+	};
+	try {
+		const headBlock = await getBlock({
+			blockNumber: BigInt(headBlockNumber),
+			includeTransactions: false
+		});
+		return {
+			head_block_number: headBlockNumber,
+			head_block_timestamp_s: Number(headBlock.timestamp)
+		};
+	} catch {
+		return {
+			head_block_number: headBlockNumber,
+			head_block_timestamp_s: fallbackHeadTimestampS
+		};
+	}
+}
+/**
+* Build wide-event telemetry fields used by indexed collector logs.
+* @param parameters - Indexed event counts and head metadata.
+* @returns Computed latency and log counters.
+*/
+function buildIndexedEventTelemetry(parameters) {
+	const insertedAtMs = parameters.insertedAtMs ?? Date.now();
+	const headTimestampMs = parameters.head_block_timestamp_s * 1e3;
+	return {
+		head_block_number: parameters.head_block_number,
+		head_block_timestamp_s: parameters.head_block_timestamp_s,
+		head_to_db_insert_latency_ms: Math.max(insertedAtMs - headTimestampMs, 0),
+		logs_ingested_count: Math.max(parameters.logsIngestedCount, 0),
+		logs_indexed_count: Math.max(parameters.logsIndexedCount, 0)
+	};
+}
+
 //#endregion
 //#region src/indexer/collectors/CollectFunctions/processors/processCollateralSeizures.ts
 /**
@@ -4058,39 +4421,40 @@ const merklePaths = s.table(EnumTableName.MERKLE_PATHS, {
 */
 function processCollateralSeizures(parameters) {
 	const { logs, chainId } = parameters;
-	const logger = getLogger();
+	const logger = getLoggerWithContext({
+		component: "indexer.collector.processor",
+		chain_id: chainId
+	});
 	const seizureEvents = [];
 	for (const rawLog of logs) {
 		if (rawLog.blockNumber === null || rawLog.logIndex === null || rawLog.transactionHash === null) {
 			logger.debug({
-				chainId,
+				event: INDEXER_COLLECTOR_LOG_SKIPPED,
 				msg: "Skipping collateral log because it is missing required fields"
 			});
 			continue;
 		}
 		if (rawLog.eventName !== liquidateEvent.name) continue;
 		const args = rawLog.args;
-		if (args?.id === void 0 || args?.borrower === void 0 || args?.seizures === void 0) {
+		const obligationId = args?.id_;
+		if (obligationId === void 0 || args?.borrower === void 0 || args?.collateralIndex === void 0 || args?.seizedAssets === void 0) {
 			logger.debug({
-				chainId,
+				event: INDEXER_COLLECTOR_LOG_SKIPPED,
 				msg: "Skipping Liquidate log for collateral because it is missing required args"
 			});
 			continue;
 		}
+		if (args.seizedAssets === 0n) continue;
 		const baseId = `${rawLog.blockNumber.toString()}-${rawLog.logIndex.toString()}-${chainId}-${rawLog.transactionHash}`;
-		for (let seizureIndex = 0; seizureIndex < args.seizures.length; seizureIndex++) {
-			const seizure = args.seizures[seizureIndex];
-			if (seizure.seized === 0n) continue;
-			seizureEvents.push({
-				id: `${baseId}-collateral-liquidate-${seizureIndex}`,
-				chainId,
-				obligationId: args.id,
-				collateralIndex: Number(seizure.collateralIndex),
-				user: args.borrower,
-				amount: seizure.seized,
-				blockNumber: Number(rawLog.blockNumber)
-			});
-		}
+		seizureEvents.push({
+			id: `${baseId}-collateral-liquidate`,
+			chainId,
+			obligationId,
+			collateralIndex: Number(args.collateralIndex),
+			user: args.borrower,
+			amount: args.seizedAssets,
+			blockNumber: Number(rawLog.blockNumber)
+		});
 	}
 	return seizureEvents;
 }
@@ -4113,12 +4477,15 @@ function processCollateralSeizures(parameters) {
 */
 function processCollateralTransfers(parameters) {
 	const { logs, chainId } = parameters;
-	const logger = getLogger();
+	const logger = getLoggerWithContext({
+		component: "indexer.collector.processor",
+		chain_id: chainId
+	});
 	const transfers = [];
 	for (const rawLog of logs) {
 		if (rawLog.blockNumber === null || rawLog.logIndex === null || rawLog.transactionHash === null) {
 			logger.debug({
-				chainId,
+				event: INDEXER_COLLECTOR_LOG_SKIPPED,
 				msg: "Skipping collateral log because it is missing required fields"
 			});
 			continue;
@@ -4127,9 +4494,10 @@ function processCollateralTransfers(parameters) {
 		const baseId = `${rawLog.blockNumber.toString()}-${rawLog.logIndex.toString()}-${chainId}-${rawLog.transactionHash}`;
 		if (eventName === supplyCollateralEvent.name) {
 			const args = rawLog.args;
-			if (args?.id === void 0 || args?.collateral === void 0 || args?.assets === void 0 || args?.onBehalf === void 0) {
+			const obligationId = args?.id_;
+			if (obligationId === void 0 || args?.collateral === void 0 || args?.assets === void 0 || args?.onBehalf === void 0) {
 				logger.debug({
-					chainId,
+					event: INDEXER_COLLECTOR_LOG_SKIPPED,
 					msg: "Skipping SupplyCollateral log because it is missing required args"
 				});
 				continue;
@@ -4138,7 +4506,7 @@ function processCollateralTransfers(parameters) {
 			transfers.push(from$9({
 				id: `${baseId}-collateral-supply`,
 				chainId,
-				contract: args.id,
+				contract: obligationId,
 				from: zeroAddress,
 				to: args.onBehalf,
 				value: args.assets,
@@ -4150,9 +4518,10 @@ function processCollateralTransfers(parameters) {
 		}
 		if (eventName === withdrawCollateralEvent.name) {
 			const args = rawLog.args;
-			if (args?.id === void 0 || args?.collateral === void 0 || args?.assets === void 0 || args?.onBehalf === void 0) {
+			const obligationId = args?.id_;
+			if (obligationId === void 0 || args?.collateral === void 0 || args?.assets === void 0 || args?.onBehalf === void 0) {
 				logger.debug({
-					chainId,
+					event: INDEXER_COLLECTOR_LOG_SKIPPED,
 					msg: "Skipping WithdrawCollateral log because it is missing required args"
 				});
 				continue;
@@ -4161,7 +4530,7 @@ function processCollateralTransfers(parameters) {
 			transfers.push(from$9({
 				id: `${baseId}-collateral-withdraw`,
 				chainId,
-				contract: args.id,
+				contract: obligationId,
 				from: args.onBehalf,
 				to: zeroAddress,
 				value: args.assets,
@@ -4187,12 +4556,15 @@ const buildGroupKey = (parameters) => {
 */
 function processConsumedLogs(parameters) {
 	const { logs, chainId } = parameters;
-	const logger = getLogger();
+	const logger = getLoggerWithContext({
+		component: "indexer.collector.processor",
+		chain_id: chainId
+	});
 	const consumedEvents = [];
 	for (const rawLog of logs) {
 		if (rawLog.blockNumber === null || rawLog.logIndex === null || rawLog.transactionHash === null) {
 			logger.debug({
-				chainId,
+				event: INDEXER_COLLECTOR_LOG_SKIPPED,
 				msg: "Skipping log because it is missing required fields"
 			});
 			continue;
@@ -4202,7 +4574,7 @@ function processConsumedLogs(parameters) {
 			const consumeArgs = rawLog.args;
 			if (consumeArgs?.user === void 0 || consumeArgs?.group === void 0 || consumeArgs?.amount === void 0) {
 				logger.debug({
-					chainId,
+					event: INDEXER_COLLECTOR_LOG_SKIPPED,
 					msg: "Skipping Consume log because it is missing required args"
 				});
 				continue;
@@ -4222,7 +4594,7 @@ function processConsumedLogs(parameters) {
 			const takeArgs = rawLog.args;
 			if (takeArgs?.maker === void 0 || takeArgs?.group === void 0 || takeArgs?.consumed === void 0) {
 				logger.debug({
-					chainId,
+					event: INDEXER_COLLECTOR_LOG_SKIPPED,
 					msg: "Skipping Take log because it is missing required args for consumed"
 				});
 				continue;
@@ -4260,7 +4632,7 @@ function processConsumedLogs(parameters) {
 * | false         | false            | from: 0x0 → to: buyer        | none                         |
 *
 * **Repay**: from: 0x0 → to: onBehalf
-* **Liquidate**: from: 0x0 → to: borrower (value = totalRepaid + badDebt)
+* **Liquidate**: from: 0x0 → to: borrower (value = repaidUnits + badDebt)
 *
 * @param parameters - The parsed event logs and chain ID.
 * @param parameters.logs - Parsed event logs from MorphoV2 (Take, Repay, Liquidate events).
@@ -4269,12 +4641,15 @@ function processConsumedLogs(parameters) {
 */
 function processDebtTransfers(parameters) {
 	const { logs, chainId } = parameters;
-	const logger = getLogger();
+	const logger = getLoggerWithContext({
+		component: "indexer.collector.processor",
+		chain_id: chainId
+	});
 	const transfers = [];
 	for (const rawLog of logs) {
 		if (rawLog.blockNumber === null || rawLog.logIndex === null || rawLog.transactionHash === null) {
 			logger.debug({
-				chainId,
+				event: INDEXER_COLLECTOR_LOG_SKIPPED,
 				msg: "Skipping debt log because it is missing required fields"
 			});
 			continue;
@@ -4283,9 +4658,10 @@ function processDebtTransfers(parameters) {
 		const baseId = `${rawLog.blockNumber.toString()}-${rawLog.logIndex.toString()}-${chainId}-${rawLog.transactionHash}`;
 		if (eventName === takeEvent.name) {
 			const args = rawLog.args;
-			if (args?.id === void 0 || args?.maker === void 0 || args?.taker === void 0 || args?.offerIsBuy === void 0 || args?.obligationUnits === void 0 || args?.buyerIsLender === void 0 || args?.sellerIsBorrower === void 0) {
+			const obligationId = args?.id_;
+			if (obligationId === void 0 || args?.maker === void 0 || args?.taker === void 0 || args?.offerIsBuy === void 0 || args?.obligationUnits === void 0 || args?.buyerIsLender === void 0 || args?.sellerIsBorrower === void 0) {
 				logger.debug({
-					chainId,
+					event: INDEXER_COLLECTOR_LOG_SKIPPED,
 					msg: "Skipping Take log because it is missing required args for debt"
 				});
 				continue;
@@ -4297,7 +4673,7 @@ function processDebtTransfers(parameters) {
 			if (!args.buyerIsLender) transfers.push(from$9({
 				id: `${baseId}-debt-buyer`,
 				chainId,
-				contract: args.id,
+				contract: obligationId,
 				from: zeroAddress,
 				to: buyer,
 				value: args.obligationUnits,
@@ -4308,7 +4684,7 @@ function processDebtTransfers(parameters) {
 			if (args.sellerIsBorrower) transfers.push(from$9({
 				id: `${baseId}-debt-seller`,
 				chainId,
-				contract: args.id,
+				contract: obligationId,
 				from: seller,
 				to: zeroAddress,
 				value: args.obligationUnits,
@@ -4320,9 +4696,10 @@ function processDebtTransfers(parameters) {
 		}
 		if (eventName === repayEvent.name) {
 			const args = rawLog.args;
-			if (args?.id === void 0 || args?.obligationUnits === void 0 || args?.onBehalf === void 0) {
+			const obligationId = args?.id_;
+			if (obligationId === void 0 || args?.obligationUnits === void 0 || args?.onBehalf === void 0) {
 				logger.debug({
-					chainId,
+					event: INDEXER_COLLECTOR_LOG_SKIPPED,
 					msg: "Skipping Repay log because it is missing required args"
 				});
 				continue;
@@ -4331,7 +4708,7 @@ function processDebtTransfers(parameters) {
 			transfers.push(from$9({
 				id: `${baseId}-debt-repay`,
 				chainId,
-				contract: args.id,
+				contract: obligationId,
 				from: zeroAddress,
 				to: args.onBehalf,
 				value: args.obligationUnits,
@@ -4343,19 +4720,20 @@ function processDebtTransfers(parameters) {
 		}
 		if (eventName === liquidateEvent.name) {
 			const args = rawLog.args;
-			if (args?.id === void 0 || args?.borrower === void 0 || args?.totalRepaid === void 0 || args?.badDebt === void 0) {
+			const obligationId = args?.id_;
+			if (obligationId === void 0 || args?.borrower === void 0 || args?.repaidUnits === void 0 || args?.badDebt === void 0) {
 				logger.debug({
-					chainId,
+					event: INDEXER_COLLECTOR_LOG_SKIPPED,
 					msg: "Skipping Liquidate log because it is missing required args"
 				});
 				continue;
 			}
-			const totalReduction = args.totalRepaid + args.badDebt;
+			const totalReduction = args.repaidUnits + args.badDebt;
 			if (totalReduction === 0n) continue;
 			transfers.push(from$9({
 				id: `${baseId}-debt-liquidate`,
 				chainId,
-				contract: args.id,
+				contract: obligationId,
 				from: zeroAddress,
 				to: args.borrower,
 				value: totalReduction,
@@ -4372,10 +4750,18 @@ function processDebtTransfers(parameters) {
 //#region src/indexer/collectors/CollectFunctions/collectMorphoV2.ts
 async function* collectMorphoV2(parameters) {
 	let { db, collector, client, lastBlockNumber: blockNumber, epoch, options: { maxBatchSize = 1e3, blockWindow } = {} } = parameters;
-	const logger = getLogger();
+	const logger = getLoggerWithContext({
+		component: "indexer.collector",
+		collector,
+		chain_id: client.chain.id
+	});
 	let startBlock = blockNumber;
 	let reorgDetected = false;
 	const { blockNumber: latestBlockNumberChain } = await db.blocks.getChain(client.chain.id);
+	const indexedEventHeadContext = await getIndexedEventHeadContext({
+		client,
+		headBlockNumber: latestBlockNumberChain
+	});
 	const stream = streamLogs({
 		client,
 		contractAddress: client.chain.custom.morpho.address,
@@ -4423,8 +4809,6 @@ async function* collectMorphoV2(parameters) {
 			}), resolveConsumedEvents({
 				dbTx,
 				consumedEvents,
-				chainId: client.chain.id,
-				collector,
 				logger
 			})]);
 			if (debtTransfers.length > 0) {
@@ -4437,14 +4821,23 @@ async function* collectMorphoV2(parameters) {
 				await dbTx.transfers.create(allCollateralTransfers);
 			}
 			await dbTx.consumed.create(resolvedConsumedEvents);
-			if (resolvedConsumedEvents.length > 0) logger.info({
+			const logsIndexedCount = countIndexedLogs({
+				resolvedConsumedEvents,
+				debtTransfers,
+				collateralTransfers: allCollateralTransfers
+			});
+			logger.info({
+				event: INDEXER_COLLECTOR_EVENTS_INDEXED,
 				msg: "Events indexed",
-				collector,
 				consumed_count: resolvedConsumedEvents.length,
 				debt_transfer_count: debtTransfers.length,
 				collateral_transfer_count: allCollateralTransfers.length,
-				chain_id: client.chain.id,
-				block_range: [startBlock, lastStreamBlockNumber]
+				block_range: [startBlock, lastStreamBlockNumber],
+				...buildIndexedEventTelemetry({
+					...indexedEventHeadContext,
+					logsIngestedCount: parsedLogs.length,
+					logsIndexedCount
+				})
 			});
 			blockNumber = lastStreamBlockNumber;
 			try {
@@ -4476,8 +4869,7 @@ async function* collectMorphoV2(parameters) {
 						positionTypeId: positionTypeId(Type.COLLATERAL_OF)
 					});
 					logger.info({
-						collector,
-						chain_id: client.chain.id,
+						event: INDEXER_COLLECTOR_REORG_COMPENSATED,
 						msg: "Reorg detected, events deleted",
 						consumed_deleted: deletedConsumed,
 						debt_transfers_deleted: deletedDebtTransfers,
@@ -4493,13 +4885,13 @@ async function* collectMorphoV2(parameters) {
 					reorgDetected = true;
 				} catch (err) {
 					const msg = "Failed to delete events when handling reorg.";
+					const error = err instanceof Error ? err : new Error(String(err));
 					logger.error({
-						collector,
-						chainId: client.chain.id,
+						event: INDEXER_COLLECTOR_REORG_COMPENSATION_FAILED,
 						msg,
-						err
+						err: error
 					});
-					throw new Error(msg, { cause: err });
+					throw new Error(msg, { cause: error });
 				}
 			}
 		});
@@ -4527,8 +4919,7 @@ async function* collectMorphoV2(parameters) {
 			positionTypeId: positionTypeId(Type.COLLATERAL_OF)
 		});
 		if (deletedConsumed > 0 || deletedDebtTransfers > 0 || deletedCollateralTransfers > 0) logger.info({
-			collector,
-			chain_id: client.chain.id,
+			event: INDEXER_COLLECTOR_REORG_COMPENSATED,
 			msg: "Reorg detected, events deleted",
 			consumed_deleted: deletedConsumed,
 			debt_transfers_deleted: deletedDebtTransfers,
@@ -4568,7 +4959,7 @@ async function resolveSeizureTransfers(parameters) {
 	return resolvedSeizureTransfers;
 }
 async function resolveConsumedEvents(parameters) {
-	const { dbTx, consumedEvents, chainId, collector, logger } = parameters;
+	const { dbTx, consumedEvents, logger } = parameters;
 	if (consumedEvents.length === 0) return [];
 	const [existingConsumedIds, consumedByGroup] = await Promise.all([getExistingConsumedIds({
 		dbTx,
@@ -4601,8 +4992,7 @@ async function resolveConsumedEvents(parameters) {
 		const delta = log.consumed - previousConsumed;
 		if (delta <= 0n) {
 			logger.debug({
-				collector,
-				chainId,
+				event: INDEXER_COLLECTOR_LOG_SKIPPED,
 				msg: "Skipping Take log because consumed did not increase",
 				previous_consumed: previousConsumed.toString(),
 				consumed: log.consumed.toString()
@@ -4621,6 +5011,15 @@ async function resolveConsumedEvents(parameters) {
 	}
 	return resolvedEvents;
 }
+function countIndexedLogs(parameters) {
+	const sourceLogIds = /* @__PURE__ */ new Set();
+	for (const consumedEvent of parameters.resolvedConsumedEvents) sourceLogIds.add(consumedEvent.id);
+	for (const transfer of [...parameters.debtTransfers, ...parameters.collateralTransfers]) sourceLogIds.add(toSourceLogId(transfer.id));
+	return sourceLogIds.size;
+}
+function toSourceLogId(derivedId) {
+	return derivedId.replace(/-(?:debt-(?:buyer|seller|repay|liquidate)|collateral-(?:supply|withdraw|liquidate))$/, "");
+}
 async function getExistingConsumedIds(parameters) {
 	const { dbTx, consumedEvents: consumedEvents$1 } = parameters;
 	const existingConsumedIds = /* @__PURE__ */ new Set();
@@ -4638,21 +5037,21 @@ async function getExistingConsumedIds(parameters) {
 }
 async function getConsumedByGroup(parameters) {
 	const { dbTx, consumedEvents } = parameters;
-	const groups$3 = /* @__PURE__ */ new Map();
+	const groups$4 = /* @__PURE__ */ new Map();
 	for (const event of consumedEvents) {
 		const key = buildGroupKey({
 			chainId: event.chainId,
 			maker: event.maker,
 			group: event.group
 		});
-		if (!groups$3.has(key)) groups$3.set(key, {
+		if (!groups$4.has(key)) groups$4.set(key, {
 			chainId: event.chainId,
 			maker: event.maker,
 			group: event.group
 		});
 	}
 	const consumedByGroup = /* @__PURE__ */ new Map();
-	const groupList = Array.from(groups$3.values());
+	const groupList = Array.from(groups$4.values());
 	for (let index = 0; index < groupList.length; index += 500) {
 		const slice = groupList.slice(index, index + 500);
 		const { rows } = await dbTx.execute(sql`
@@ -4710,17 +5109,20 @@ function transfersToPositions(transfers) {
 
 //#endregion
 //#region src/indexer/collectors/CollectFunctions/collectOffers.ts
-const ERC20_TYPE_ID = Object.values(Type).indexOf(Type.ERC20) + 1;
 async function* collectOffersV2(parameters) {
 	let { db, collector, client, lastBlockNumber: blockNumber, gatekeeper, options: { maxBatchSize = 1e3, blockWindow } = {} } = parameters;
-	const logger = getLogger();
+	const logger = getLoggerWithContext({
+		component: "indexer.collector",
+		collector,
+		chain_id: client.chain.id
+	});
 	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
+			event: INDEXER_COLLECTOR_INVALID_CHAIN_CONFIG,
+			msg
 		});
 		throw new Error(msg);
 	}
@@ -4730,6 +5132,10 @@ async function* collectOffersV2(parameters) {
 		verifyingContract: morphoV2
 	};
 	const { blockNumber: latestBlockNumberChain } = await db.blocks.getChain(client.chain.id);
+	const indexedEventHeadContext = await getIndexedEventHeadContext({
+		client,
+		headBlockNumber: latestBlockNumberChain
+	});
 	const stream = streamLogs({
 		client,
 		contractAddress: client.chain.custom.mempool.address,
@@ -4763,11 +5169,11 @@ async function* collectOffersV2(parameters) {
 				const signerMismatch = tree.offers.find((offer) => offer.maker.toLowerCase() !== signer.toLowerCase());
 				if (signerMismatch) {
 					logger.debug({
+						event: INDEXER_COLLECTOR_OFFER_TREE_REJECTED,
 						msg: "Tree rejected: signer mismatch",
 						reason: "signer_mismatch",
 						signer,
-						maker: signerMismatch.maker,
-						chain_id: client.chain.id
+						maker: signerMismatch.maker
 					});
 					continue;
 				}
@@ -4780,80 +5186,81 @@ async function* collectOffersV2(parameters) {
 			} catch (err) {
 				const reason = err instanceof DecodeError && err.message.includes("signature") ? "invalid_signature" : "decode_failed";
 				logger.debug({
+					event: INDEXER_COLLECTOR_OFFER_TREE_DECODE_FAILED,
 					msg: "Tree decode failed",
 					reason,
-					chain_id: client.chain.id,
 					err: err instanceof Error ? err.message : String(err)
 				});
 			}
 		}
-		await db.transaction(async (dbTx) => {
-			const { epoch, blockNumber: latestBlockNumber } = await dbTx.blocks.getChain(client.chain.id);
-			const treesToInsert = [];
-			const pathsToInsert = [];
-			let totalValidOffers = 0;
-			const offersWithBlock = [];
-			for (const { tree, signature, blockNumber: treeBlockNumber } of decodedTrees) try {
-				const allowedResults = await gatekeeper.isAllowed({
-					offers: tree.offers,
-					chainId: client.chain.id
-				});
-				const hasBlockWindowViolation = treeBlockNumber > latestBlockNumber;
-				if (!(allowedResults.issues.length === 0 && allowedResults.valid.length === tree.offers.length) || hasBlockWindowViolation) {
-					if (allowedResults.issues.length > 0) {
-						const hasMixedMaker = allowedResults.issues.some((i) => i.ruleName === "mixed_maker");
-						logger.debug({
-							msg: "Tree offers rejected by gatekeeper",
-							reason: hasMixedMaker ? "mixed_maker" : "gatekeeper_rejected",
-							chain_id: client.chain.id,
-							issues_count: allowedResults.issues.length
-						});
-					} else if (hasBlockWindowViolation) logger.debug({
-						msg: "Tree rejected: offers outside block window",
-						reason: "block_window",
-						chain_id: client.chain.id
+		const { blockNumber: latestBlockNumber } = await db.blocks.getChain(client.chain.id);
+		const treesToInsert = [];
+		const pathsToInsert = [];
+		let totalValidOffers = 0;
+		const offersWithBlock = [];
+		for (const { tree, signature, blockNumber: treeBlockNumber } of decodedTrees) try {
+			const allowedResults = await gatekeeper.isAllowed({
+				offers: tree.offers,
+				chainId: client.chain.id
+			});
+			const hasBlockWindowViolation = treeBlockNumber > latestBlockNumber;
+			if (!(allowedResults.issues.length === 0 && allowedResults.valid.length === tree.offers.length) || hasBlockWindowViolation) {
+				if (allowedResults.issues.length > 0) {
+					const hasMixedMaker = allowedResults.issues.some((i) => i.ruleName === "mixed_maker");
+					logger.debug({
+						event: INDEXER_COLLECTOR_OFFER_TREE_REJECTED,
+						msg: "Tree offers rejected by gatekeeper",
+						reason: hasMixedMaker ? "mixed_maker" : "gatekeeper_rejected",
+						issues_count: allowedResults.issues.length
 					});
-					continue;
-				}
-				treesToInsert.push({
-					root: tree.root,
-					signature
+				} else if (hasBlockWindowViolation) logger.debug({
+					event: INDEXER_COLLECTOR_OFFER_TREE_REJECTED,
+					msg: "Tree rejected: offers outside block window",
+					reason: "block_window"
 				});
-				totalValidOffers += tree.offers.length;
-				const obligationIdsByOfferHash = /* @__PURE__ */ new Map();
-				for (const offer of tree.offers) {
-					const offerHash = hash(offer).toLowerCase();
-					const obligationId$1 = obligationId(offer, {
-						chainId: client.chain.id,
-						morphoV2
-					}).toLowerCase();
-					offersWithBlock.push({
-						offer,
-						blockNumber: treeBlockNumber,
-						obligationId: obligationId$1
-					});
-					obligationIdsByOfferHash.set(offerHash, obligationId$1);
-				}
-				for (const proof of proofs(tree)) {
-					const offerHash = hash(proof.offer).toLowerCase();
-					const obligationId = obligationIdsByOfferHash.get(offerHash);
-					if (obligationId === void 0) continue;
-					pathsToInsert.push({
-						offerHash,
-						obligationId,
-						treeRoot: tree.root,
-						proof: proof.path
-					});
-				}
-			} catch (err) {
-				const error = err instanceof Error ? err : new Error(String(err));
-				logger.error({
-					err: error,
-					msg: "Gatekeeper validation failed",
-					chain_id: client.chain.id
+				continue;
+			}
+			treesToInsert.push({
+				root: tree.root,
+				signature
+			});
+			totalValidOffers += tree.offers.length;
+			const obligationIdsByOfferHash = /* @__PURE__ */ new Map();
+			for (const offer of tree.offers) {
+				const offerHash = hash(offer).toLowerCase();
+				const obligationId$1 = obligationId(offer, {
+					chainId: client.chain.id,
+					morphoV2
+				}).toLowerCase();
+				offersWithBlock.push({
+					offer,
+					blockNumber: treeBlockNumber,
+					obligationId: obligationId$1
+				});
+				obligationIdsByOfferHash.set(offerHash, obligationId$1);
+			}
+			for (const proof of proofs(tree)) {
+				const offerHash = hash(proof.offer).toLowerCase();
+				const obligationId = obligationIdsByOfferHash.get(offerHash);
+				if (obligationId === void 0) continue;
+				pathsToInsert.push({
+					offerHash,
+					obligationId,
+					treeRoot: tree.root,
+					proof: proof.path
 				});
-				throw new Error("Gatekeeper validation failed", { cause: error });
 			}
+		} catch (err) {
+			const error = err instanceof Error ? err : new Error(String(err));
+			logger.error({
+				event: INDEXER_COLLECTOR_GATEKEEPER_VALIDATION_FAILED,
+				err: error,
+				msg: "Gatekeeper validation failed"
+			});
+			throw new Error("Gatekeeper validation failed", { cause: error });
+		}
+		await db.transaction(async (dbTx) => {
+			const { epoch } = await dbTx.blocks.getChain(client.chain.id);
 			const dependencies = buildOfferDependencies({
 				offers: offersWithBlock,
 				chainId: client.chain.id,
@@ -4882,13 +5289,17 @@ async function* collectOffersV2(parameters) {
 					blockNumber,
 					epoch
 				});
-				if (totalValidOffers > 0) logger.info({
-					msg: `New offers`,
-					collector,
+				logger.info({
+					event: INDEXER_COLLECTOR_OFFERS_INDEXED,
+					msg: "Offers batch processed",
 					count: totalValidOffers,
 					trees_count: treesToInsert.length,
-					chain_id: client.chain.id,
-					block_range: [startBlock, lastStreamBlockNumber]
+					block_range: [startBlock, lastStreamBlockNumber],
+					...buildIndexedEventTelemetry({
+						...indexedEventHeadContext,
+						logsIngestedCount: logs.length,
+						logsIndexedCount: treesToInsert.length
+					})
 				});
 			} catch (_) {
 				try {
@@ -4902,8 +5313,7 @@ async function* collectOffersV2(parameters) {
 						chainId: client.chain.id
 					});
 					logger.info({
-						collector,
-						chain_id: client.chain.id,
+						event: INDEXER_COLLECTOR_REORG_COMPENSATED,
 						msg: `Reorg detected, offers deleted`,
 						count: deleted,
 						block_number: blockNumber
@@ -4917,11 +5327,11 @@ async function* collectOffersV2(parameters) {
 					reorgDetected = true;
 				} catch (err) {
 					const msg = "Failed to delete offers when handling reorg.";
+					const error = err instanceof Error ? err : new Error(String(err));
 					logger.error({
-						collector,
-						chainId: client.chain.id,
+						event: INDEXER_COLLECTOR_REORG_COMPENSATION_FAILED,
 						msg,
-						err
+						err: error
 					});
 					throw new Error(msg);
 				}
@@ -4943,37 +5353,62 @@ function decodeCallbacks(parameters) {
 	const positions = [];
 	const lots = [];
 	for (const { offer, blockNumber: offerBlockNumber, obligationId } of offers) {
-		if (!offer.buy) continue;
 		if (!isEmptyCallback(offer)) continue;
-		const loanToken = offer.loanToken.toLowerCase();
-		positions.push(from$12({
-			chainId,
-			contract: loanToken,
-			user: offer.maker,
-			type: Type.ERC20,
-			asset: loanToken,
-			blockNumber: offerBlockNumber
-		}));
-		lots.push({
-			positionChainId: chainId,
-			positionContract: loanToken,
-			positionUser: offer.maker,
-			positionTypeId: ERC20_TYPE_ID,
-			group: offer.group,
-			obligationId,
-			size: offer.assets
-		});
-		callbacks.push({
-			offerHash: hash(offer),
-			obligationId,
-			callbacks: [{
+		if (offer.buy) {
+			const loanToken = offer.loanToken.toLowerCase();
+			const positionTypeId$3 = positionTypeId(Type.ERC20);
+			positions.push(from$12({
 				chainId,
 				contract: loanToken,
 				user: offer.maker,
-				amount: offer.assets,
-				positionTypeId: ERC20_TYPE_ID
-			}]
-		});
+				type: Type.ERC20,
+				asset: loanToken,
+				blockNumber: offerBlockNumber
+			}));
+			lots.push({
+				positionChainId: chainId,
+				positionContract: loanToken,
+				positionUser: offer.maker,
+				positionTypeId: positionTypeId$3,
+				group: offer.group,
+				obligationId,
+				size: offer.assets
+			});
+			callbacks.push({
+				offerHash: hash(offer),
+				obligationId,
+				callbacks: [{
+					chainId,
+					contract: loanToken,
+					user: offer.maker,
+					positionTypeId: positionTypeId$3,
+					type: CallbackType.Empty
+				}]
+			});
+		} else {
+			const contract = obligationId;
+			const positionTypeId$2 = positionTypeId(Type.COLLATERAL_OF);
+			lots.push({
+				positionChainId: chainId,
+				positionContract: contract,
+				positionUser: offer.maker,
+				positionTypeId: positionTypeId$2,
+				group: offer.group,
+				obligationId,
+				size: offer.assets
+			});
+			callbacks.push({
+				offerHash: hash(offer),
+				obligationId,
+				callbacks: [{
+					chainId,
+					contract,
+					user: offer.maker,
+					positionTypeId: positionTypeId$2,
+					type: CallbackType.Empty
+				}]
+			});
+		}
 	}
 	return {
 		callbacks,
@@ -5149,8 +5584,11 @@ async function snapshotERC20Positions(parameters) {
 * @returns Positions - {@link snapshotVaultPositions.ReturnType}
 */
 async function snapshotVaultPositions(parameters) {
-	const logger = getLogger();
 	const { client, positions: oldPositions, blockNumber, options: { maxBatchSize = 1e3, retryAttempts = 5, retryDelayMs = 500 } = {} } = parameters;
+	const logger = getLoggerWithContext({
+		component: "indexer.collector.fetcher",
+		chain_id: client.chain.id
+	});
 	const calls = [];
 	const contracts = /* @__PURE__ */ new Map();
 	const positions = structuredClone(oldPositions);
@@ -5176,8 +5614,8 @@ async function snapshotVaultPositions(parameters) {
 				} catch (err) {
 					if (err instanceof DenominatorIsZeroError) {
 						logger.error({
+							event: INDEXER_COLLECTOR_POSITION_CONVERSION_FAILED,
 							msg: "Failed to convert shares to assets",
-							chain_id: client.chain.id,
 							block_number: blockNumber,
 							position_contract: position.contract,
 							position_user: position.user,
@@ -5257,11 +5695,18 @@ async function snapshotVaultPositions(parameters) {
 
 //#endregion
 //#region src/indexer/collectors/CollectFunctions/collectPositions.ts
+const MAX_POSITIONS_BLOCK_WINDOW = 500;
+const POSITIONS_PAGE_SIZE = 1e3;
 async function* collectPositions(parameters) {
 	let { db, collector, client, lastBlockNumber: blockNumber, epoch, options: { maxBatchSize = 1e3, retryAttempts = 5, retryDelayMs = 500, blockWindow } = {} } = parameters;
-	const logger = getLogger();
+	const logger = getLoggerWithContext({
+		component: "indexer.collector",
+		collector,
+		chain_id: client.chain.id
+	});
 	let startBlock = blockNumber;
 	let reorgDetected = false;
+	const safeBlockWindow = blockWindow === void 0 ? MAX_POSITIONS_BLOCK_WINDOW : Math.min(blockWindow, MAX_POSITIONS_BLOCK_WINDOW);
 	const TransferEvent = {
 		type: "event",
 		name: "Transfer",
@@ -5284,6 +5729,107 @@ async function* collectPositions(parameters) {
 		]
 	};
 	const { blockNumber: latestBlockNumberChain } = await db.blocks.getChain(client.chain.id);
+	const indexedEventHeadContext = await getIndexedEventHeadContext({
+		client,
+		headBlockNumber: latestBlockNumberChain
+	});
+	const hasEmptyPositions = await _hasPositions({
+		db,
+		chainId: client.chain.id,
+		filled: false
+	});
+	const hasFilledPositions = await _hasPositions({
+		db,
+		chainId: client.chain.id,
+		filled: true
+	});
+	let pendingNewPositions = [];
+	if (hasEmptyPositions) {
+		const emptyPositions = await _getPositions({
+			db,
+			chainId: client.chain.id,
+			filled: false
+		});
+		try {
+			pendingNewPositions = (await _snapshot({
+				positions: emptyPositions,
+				blockNumber: latestBlockNumberChain,
+				client,
+				maxBatchSize,
+				retryAttempts,
+				retryDelayMs
+			})).map((position) => ({
+				...position,
+				blockNumber: position.blockNumber + 1
+			}));
+		} catch (err) {
+			logger.error({
+				event: INDEXER_COLLECTOR_POSITIONS_SNAPSHOT_FAILED,
+				msg: "Failed to snapshot new empty positions",
+				block_number: latestBlockNumberChain,
+				err
+			});
+			yield startBlock;
+			return;
+		}
+	}
+	if (!hasFilledPositions) {
+		blockNumber = latestBlockNumberChain;
+		const positionsToInsert = pendingNewPositions;
+		try {
+			await db.transaction(async (dbTx) => {
+				const insertPositions = async () => {
+					if (positionsToInsert.length === 0) return 0;
+					try {
+						return await dbTx.positions.upsert(positionsToInsert);
+					} catch (err) {
+						throw new InsertPositionsError(err);
+					}
+				};
+				const saveBlockNumber = async () => {
+					try {
+						await dbTx.blocks.advanceCollector({
+							collectorName: collector,
+							chainId: client.chain.id,
+							blockNumber,
+							epoch
+						});
+					} catch (_) {
+						throw new ReorgError(blockNumber);
+					}
+				};
+				const positionsIndexedCount = await insertPositions();
+				logger.info({
+					event: INDEXER_COLLECTOR_POSITIONS_INDEXED,
+					msg: "Positions batch processed",
+					count: positionsIndexedCount,
+					block_number: latestBlockNumberChain,
+					...buildIndexedEventTelemetry({
+						...indexedEventHeadContext,
+						logsIngestedCount: positionsToInsert.length,
+						logsIndexedCount: positionsIndexedCount
+					})
+				});
+				await saveBlockNumber();
+			});
+		} catch (err) {
+			if (err instanceof ReorgError) return;
+			if (err instanceof InsertPositionsError) {
+				logger.error({
+					event: INDEXER_COLLECTOR_POSITIONS_INSERT_FAILED,
+					msg: "Failed to insert positions",
+					count: positionsToInsert.length,
+					block_number: latestBlockNumberChain,
+					err
+				});
+				throw err.cause;
+			}
+			throw err;
+		}
+		startBlock = blockNumber;
+		yield blockNumber;
+		return;
+	}
 	const stream = streamLogs({
 		client,
 		event: TransferEvent,
@@ -5292,7 +5838,7 @@ async function* collectPositions(parameters) {
 		order: "asc",
 		options: {
 			maxBatchSize,
-			blockWindow
+			blockWindow: safeBlockWindow
 		}
 	});
 	for await (const { logs, blockNumber: lastStreamBlockNumber } of stream) {
@@ -5305,8 +5851,7 @@ async function* collectPositions(parameters) {
 		for (const log of parsedLogs) {
 			if (log.blockNumber === null || log.logIndex === null || log.transactionHash === null) {
 				logger.debug({
-					collector,
-					chainId: client.chain.id,
+					event: INDEXER_COLLECTOR_LOG_SKIPPED,
 					msg: "Skipping log because it is missing required fields"
 				});
 				continue;
@@ -5323,63 +5868,21 @@ async function* collectPositions(parameters) {
 				blockNumber: Number(log.blockNumber)
 			}));
 		}
-		const { positions } = await db.positions.get({
-			chainId: client.chain.id,
-			filled: false,
-			type: Type.ERC20
-		});
-		const newPositions = [];
-		try {
-			newPositions.push(...(await _snapshot({
-				positions,
-				blockNumber: latestBlockNumberChain,
-				client,
-				maxBatchSize,
-				retryAttempts,
-				retryDelayMs
-			})).map((p) => ({
-				...p,
-				blockNumber: p.blockNumber + 1
-			})));
-		} catch (err) {
-			logger.error({
-				msg: "Failed to snapshot new empty positions",
-				collector,
-				chain_id: client.chain.id,
-				block_number: latestBlockNumberChain,
-				err
-			});
-			yield startBlock;
-			return;
-		}
+		const positionsToInsert = pendingNewPositions;
 		try {
 			await db.transaction(async (dbTx) => {
 				const insertPositions = async () => {
-					if (newPositions.length === 0) return;
+					if (positionsToInsert.length === 0) return 0;
 					try {
-						const count = await dbTx.positions.upsert(newPositions);
-						logger.info({
-							msg: `New positions`,
-							collector,
-							count,
-							chain_id: client.chain.id,
-							block_number: latestBlockNumberChain
-						});
+						return await dbTx.positions.upsert(positionsToInsert);
 					} catch (err) {
 						throw new InsertPositionsError(err);
 					}
 				};
 				const insertTransfers = async () => {
-					if (transfers.length === 0) return;
+					if (transfers.length === 0) return 0;
 					try {
-						const created = await dbTx.transfers.create(transfers);
-						logger.info({
-							msg: `New transfers`,
-							collector,
-							count: created,
-							chain_id: client.chain.id,
-							block_range: [startBlock, blockNumber]
-						});
+						return await dbTx.transfers.create(transfers);
 					} catch (err) {
 						throw new InsertTransfersError(err);
 					}
@@ -5396,27 +5899,48 @@ async function* collectPositions(parameters) {
 						throw new ReorgError(blockNumber);
 					}
 				};
-				await insertPositions();
-				await insertTransfers();
+				const positionsIndexedCount = await insertPositions();
+				const transfersIndexedCount = await insertTransfers();
+				logger.info({
+					event: INDEXER_COLLECTOR_POSITIONS_INDEXED,
+					msg: "Positions batch processed",
+					count: positionsIndexedCount,
+					block_number: latestBlockNumberChain,
+					...buildIndexedEventTelemetry({
+						...indexedEventHeadContext,
+						logsIngestedCount: positionsToInsert.length,
+						logsIndexedCount: positionsIndexedCount
+					})
+				});
+				logger.info({
+					event: INDEXER_COLLECTOR_TRANSFERS_INDEXED,
+					msg: "Transfers batch processed",
+					count: transfersIndexedCount,
+					block_range: [startBlock, blockNumber],
+					...buildIndexedEventTelemetry({
+						...indexedEventHeadContext,
+						logsIngestedCount: transfers.length,
+						logsIndexedCount: transfersIndexedCount
+					})
+				});
 				await saveBlockNumber();
 			});
+			pendingNewPositions = [];
 		} catch (err) {
 			if (err instanceof ReorgError) {
 				logger.info({
+					event: INDEXER_COLLECTOR_REORG_DETECTED,
 					msg: "Reorg detected, positions and transfers insertion aborted",
-					collector,
-					count: newPositions.length,
-					chain_id: client.chain.id,
+					count: positionsToInsert.length,
 					block_number: blockNumber
 				});
 				reorgDetected = true;
 			}
 			if (err instanceof InsertPositionsError) {
 				logger.error({
+					event: INDEXER_COLLECTOR_POSITIONS_INSERT_FAILED,
 					msg: "Failed to insert positions",
-					collector,
-					count: newPositions.length,
-					chain_id: client.chain.id,
+					count: positionsToInsert.length,
 					block_number: latestBlockNumberChain,
 					err
 				});
@@ -5424,10 +5948,9 @@ async function* collectPositions(parameters) {
 			}
 			if (err instanceof InsertTransfersError) {
 				logger.error({
+					event: INDEXER_COLLECTOR_TRANSFERS_INSERT_FAILED,
 					msg: "Failed to insert transfers",
-					collector,
 					count: transfers.length,
-					chain_id: client.chain.id,
 					block_number: blockNumber,
 					err
 				});
@@ -5436,7 +5959,7 @@ async function* collectPositions(parameters) {
 		}
 		if (!reorgDetected) {
 			startBlock = blockNumber;
-			if (newPositions.length === 0 && transfers.length === 0 && lastStreamBlockNumber !== latestBlockNumberChain) continue;
+			if (positionsToInsert.length === 0 && transfers.length === 0 && lastStreamBlockNumber !== latestBlockNumberChain) continue;
 			yield blockNumber;
 			continue;
 		}
@@ -5453,10 +5976,9 @@ async function* collectPositions(parameters) {
 					type: Type.ERC20
 				});
 				logger.info({
+					event: INDEXER_COLLECTOR_REORG_COMPENSATED,
 					msg: "Reorg detected, positions set to empty",
-					collector,
 					count: emptied,
-					chain_id: client.chain.id,
 					block_number_gte: blockNumber + 1
 				});
 				await dbTx.blocks.advanceCollector({
@@ -5467,11 +5989,11 @@ async function* collectPositions(parameters) {
 				});
 			} catch (err) {
 				const msg = "Failed to revert to ancestor block when handling reorg.";
+				const error = err instanceof Error ? err : new Error(String(err));
 				logger.error({
-					collector,
-					chainId: client.chain.id,
+					event: INDEXER_COLLECTOR_REORG_COMPENSATION_FAILED,
 					msg,
-					err
+					err: error
 				});
 				throw new Error(msg);
 			}
@@ -5479,6 +6001,34 @@ async function* collectPositions(parameters) {
 		return;
 	}
 }
+async function _hasPositions(parameters) {
+	const { db, chainId, filled } = parameters;
+	const { positions } = await db.positions.get({
+		chainId,
+		filled,
+		type: Type.ERC20,
+		limit: 1
+	});
+	return positions.length > 0;
+}
+async function _getPositions(parameters) {
+	const { db, chainId, filled } = parameters;
+	const positions = [];
+	let cursor;
+	while (true) {
+		const page = await db.positions.get({
+			chainId,
+			filled,
+			type: Type.ERC20,
+			limit: POSITIONS_PAGE_SIZE,
+			cursor
+		});
+		positions.push(...page.positions);
+		if (!page.nextCursor) break;
+		cursor = page.nextCursor;
+	}
+	return positions;
+}
 /**
 * @internal
 *
@@ -5547,9 +6097,17 @@ var InsertTransfersError = class extends BaseError {
 */
 async function* collectPrices(parameters) {
 	const { db, collector, client, options: { maxBatchSize = 5e3, retryAttempts = 5, retryDelayMs = 500 } = {} } = parameters;
-	const logger = getLogger();
+	const logger = getLoggerWithContext({
+		component: "indexer.collector",
+		collector,
+		chain_id: client.chain.id
+	});
 	let blockNumber = parameters.lastBlockNumber;
 	const [oracles, { blockNumber: latestBlockNumberChain, epoch }] = await Promise.all([db.oracles.get({ chainId: client.chain.id }), db.blocks.getChain(client.chain.id)]);
+	const indexedEventHeadContext = await getIndexedEventHeadContext({
+		client,
+		headBlockNumber: latestBlockNumberChain
+	});
 	const updatedOracles = [];
 	try {
 		const pricesMap = await fetchOraclePrices({
@@ -5573,9 +6131,8 @@ async function* collectPrices(parameters) {
 		}
 	} catch (err) {
 		logger.error({
+			event: INDEXER_COLLECTOR_ORACLE_FETCH_FAILED,
 			msg: "Failed to fetch oracle prices",
-			collector,
-			chain_id: client.chain.id,
 			block_number: latestBlockNumberChain,
 			err
 		});
@@ -5585,16 +6142,18 @@ async function* collectPrices(parameters) {
 	let reorgDetected = false;
 	try {
 		await db.transaction(async (dbTx) => {
-			if (updatedOracles.length > 0) {
-				await dbTx.oracles.upsert(updatedOracles);
-				logger.info({
-					msg: "Oracle prices updated",
-					collector,
-					count: updatedOracles.length,
-					chain_id: client.chain.id,
-					block_number: latestBlockNumberChain
-				});
-			}
+			if (updatedOracles.length > 0) await dbTx.oracles.upsert(updatedOracles);
+			logger.info({
+				event: INDEXER_COLLECTOR_ORACLES_INDEXED,
+				msg: "Oracle prices updated",
+				count: updatedOracles.length,
+				block_number: latestBlockNumberChain,
+				...buildIndexedEventTelemetry({
+					...indexedEventHeadContext,
+					logsIngestedCount: 0,
+					logsIndexedCount: 0
+				})
+			});
 			try {
 				await dbTx.blocks.advanceCollector({
 					collectorName: collector,
@@ -5610,10 +6169,9 @@ async function* collectPrices(parameters) {
 	} catch (err) {
 		if (err instanceof ReorgError) {
 			logger.info({
+				event: INDEXER_COLLECTOR_REORG_DETECTED,
 				msg: "Reorg detected, prices update aborted",
-				collector,
 				count: updatedOracles.length,
-				chain_id: client.chain.id,
 				block_number: latestBlockNumberChain
 			});
 			reorgDetected = true;
@@ -5638,11 +6196,11 @@ async function* collectPrices(parameters) {
 			});
 		} catch (err) {
 			const msg = "Failed to revert to ancestor block when handling reorg.";
+			const error = err instanceof Error ? err : new Error(String(err));
 			logger.error({
-				collector,
-				chainId: client.chain.id,
+				event: INDEXER_COLLECTOR_REORG_COMPENSATION_FAILED,
 				msg,
-				err
+				err: error
 			});
 			throw new Error(msg);
 		}
@@ -5654,7 +6212,7 @@ async function* collectPrices(parameters) {
 //#region src/indexer/collectors/CollectorBuilder.ts
 function createBuilder(parameters) {
 	const { client, db, gatekeeper, options: { maxBlockNumber, blockWindow, interval } = {} } = parameters;
-	const createCollector = (name, collect) => create$20({
+	const createCollector = (name, collect) => create$21({
 		name,
 		collect,
 		client,
@@ -5665,7 +6223,7 @@ function createBuilder(parameters) {
 		}
 	});
 	return {
-		buildOffersCollector: ({ options: { maxBatchSize = 1e3 } = {} }) => {
+		buildOffersCollector: ({ options: { maxBatchSize = 1e4 } = {} }) => {
 			return createCollector("offers", (p) => collectOffersV2({
 				...p,
 				gatekeeper,
@@ -5677,7 +6235,7 @@ function createBuilder(parameters) {
 				}
 			}));
 		},
-		buildMorphoV2Collector: ({ options: { maxBatchSize = 1e3 } = {} } = {}) => {
+		buildMorphoV2Collector: ({ options: { maxBatchSize = 1e4 } = {} } = {}) => {
 			return createCollector("morpho_v2", (p) => collectMorphoV2({
 				...p,
 				collector: "morpho_v2",
@@ -5687,7 +6245,7 @@ function createBuilder(parameters) {
 				}
 			}));
 		},
-		buildPricesCollector: ({ options: { maxBatchSize = 5e3, retryAttempts, retryDelayMs } = {} } = {}) => {
+		buildPricesCollector: ({ options: { maxBatchSize = 1e4, retryAttempts, retryDelayMs } = {} } = {}) => {
 			return createCollector("prices", (p) => collectPrices({
 				...p,
 				collector: "prices",
@@ -5698,7 +6256,7 @@ function createBuilder(parameters) {
 				}
 			}));
 		},
-		buildPositionsCollector: ({ options: { maxBatchSize = 1e3, retryAttempts, retryDelayMs } = {} } = {}) => {
+		buildPositionsCollector: ({ options: { maxBatchSize = 1e4, retryAttempts, retryDelayMs } = {} } = {}) => {
 			return createCollector("positions", (p) => collectPositions({
 				...p,
 				collector: "positions",
@@ -5746,11 +6304,11 @@ const from$7 = (parameters) => {
 //#endregion
 //#region src/indexer/Indexer.ts
 var Indexer_exports = /* @__PURE__ */ __exportAll({
-	create: () => create$18,
+	create: () => create$19,
 	from: () => from$6
 });
 function from$6(config) {
-	const { client, gatekeeper, db, interval = 1e4, maxBatchSize = 1e3, maxBlockNumber, blockWindow, retryAttempts, retryDelayMs } = config;
+	const { client, gatekeeper, db, interval = 1e4, maxBatchSize = 1e4, maxBlockNumber, blockWindow, retryAttempts, retryDelayMs } = config;
 	const { offersCollector, morphoV2Collector, positionsCollector, pricesCollector } = from$7({
 		client,
 		db,
@@ -5762,7 +6320,7 @@ function from$6(config) {
 		retryAttempts,
 		retryDelayMs
 	});
-	return create$18({
+	return create$19({
 		client,
 		collectors: [
 			offersCollector,
@@ -5772,7 +6330,7 @@ function from$6(config) {
 		]
 	});
 }
-function create$18(params) {
+function create$19(params) {
 	const { collectors, client } = params;
 	const indexerId = `${client.chain.id.toString()}.indexer`;
 	const tracer = getTracer(`router.${indexerId}`);
@@ -5801,12 +6359,12 @@ function create$18(params) {
 
 //#endregion
 //#region src/api/Health.ts
-var Health_exports = /* @__PURE__ */ __exportAll({ create: () => create$17 });
+var Health_exports = /* @__PURE__ */ __exportAll({ create: () => create$18 });
 const DEFAULT_MAX_ALLOWED_LAG = 5;
 /**
 * Create a health service that exposes collector and chain block numbers.
 */
-function create$17(parameters) {
+function create$18(parameters) {
 	const { db, maxAllowedLag = DEFAULT_MAX_ALLOWED_LAG, healthClients, chainRegistry } = parameters;
 	const loadSnapshot = async () => {
 		const [collectorRows, chainRows, remoteBlockByChainId] = await Promise.all([
@@ -5821,8 +6379,8 @@ function create$17(parameters) {
 			updatedAt: chain.updatedAt
 		});
 		const configuredChainIds = chainRegistry?.list().map((chain) => chain.id) ?? [];
-		const knownChainIds = new Set(configuredChainIds);
-		for (const chain of chainRows) knownChainIds.add(chain.chainId);
+		const observedChainIds = /* @__PURE__ */ new Set();
+		for (const chain of chainRows) observedChainIds.add(chain.chainId);
 		const collectorKey = (chainId, name) => `${chainId}:${name}`;
 		const collectorsByKey = /* @__PURE__ */ new Map();
 		for (const row of collectorRows) collectorsByKey.set(collectorKey(row.chainId, row.collectorName), {
@@ -5831,15 +6389,15 @@ function create$17(parameters) {
 			blockNumber: row.blockNumber,
 			updatedAt: row.updatedAt
 		});
-		for (const row of collectorRows) knownChainIds.add(row.chainId);
-		const expectedChainIds = configuredChainIds.length > 0 ? configuredChainIds : Array.from(knownChainIds);
-		const missingChains = expectedChainIds.filter((chainId) => !chainById.has(chainId)).sort((a, b) => a - b > 0 ? 1 : -1);
-		const missingCollectors = expectedChainIds.flatMap((chainId) => [...names].sort().filter((name) => !collectorsByKey.has(collectorKey(chainId, name))).map((name) => ({
+		for (const row of collectorRows) observedChainIds.add(row.chainId);
+		const scopedChainIds = configuredChainIds.length > 0 ? configuredChainIds : Array.from(observedChainIds);
+		const missingChains = scopedChainIds.filter((chainId) => !chainById.has(chainId)).sort((a, b) => a - b > 0 ? 1 : -1);
+		const missingCollectors = scopedChainIds.flatMap((chainId) => [...names].sort().filter((name) => !collectorsByKey.has(collectorKey(chainId, name))).map((name) => ({
 			chainId,
 			name
 		}))).sort((a, b) => a.chainId === b.chainId ? a.name.localeCompare(b.name) : a.chainId - b.chainId);
-		const initialized = knownChainIds.size > 0 && missingChains.length === 0 && missingCollectors.length === 0;
-		const collectors = Array.from(knownChainIds).sort((a, b) => a - b > 0 ? 1 : -1).flatMap((chainId) => [...names].sort().map((name) => {
+		const initialized = scopedChainIds.length > 0 && missingChains.length === 0 && missingCollectors.length === 0;
+		const collectors = Array.from(scopedChainIds).sort((a, b) => a - b > 0 ? 1 : -1).flatMap((chainId) => [...names].sort().map((name) => {
 			const row = collectorsByKey.get(collectorKey(chainId, name));
 			const chain = chainById.get(chainId);
 			const blockNumber = row?.blockNumber ?? null;
@@ -5858,7 +6416,7 @@ function create$17(parameters) {
 				initialized: row !== void 0
 			};
 		}));
-		const chains = Array.from(knownChainIds).sort((a, b) => a - b > 0 ? 1 : -1).map((chainId) => {
+		const chains = Array.from(scopedChainIds).sort((a, b) => a - b > 0 ? 1 : -1).map((chainId) => {
 			const chain = chainById.get(chainId);
 			return {
 				chainId,
@@ -5916,6 +6474,152 @@ async function getRemoteBlockNumbers(healthClients) {
 	return new Map(results.map((r) => [r.chainId, r.remoteBlock]));
 }
 
+//#endregion
+//#region src/observability/Hono.ts
+const requestIdContextKey = "request_id";
+const requestStartedAtContextKey = "request_started_at";
+const unmatchedRouteLabel = "/*";
+/**
+* Install shared request tracing and structured logging on a Hono app.
+* @param app - Hono app to instrument.
+* @param parameters - Observability configuration.
+*/
+function init(app, parameters) {
+	const requestIdHeader = (parameters.requestIdHeader ?? "x-request-id").toLowerCase();
+	app.use("*", createRequestObservabilityMiddleware({
+		component: parameters.component,
+		tracerName: parameters.tracerName,
+		requestIdHeader
+	}));
+	app.onError(createObservabilityErrorHandler({
+		component: parameters.component,
+		toFailurePayload: parameters.toFailurePayload,
+		adaptFailurePayload: parameters.adaptFailurePayload,
+		requestIdHeader
+	}));
+}
+/**
+* Build a middleware that emits one completion event per request and enriches span attributes.
+* @param parameters - Request logging configuration.
+* @returns Hono middleware.
+*/
+function createRequestObservabilityMiddleware(parameters) {
+	const tracer = getTracer(parameters.tracerName);
+	return async (c, next) => {
+		const method = c.req.method;
+		const path = c.req.path;
+		const requestId = resolveRequestId(c.req.header(parameters.requestIdHeader));
+		const startedAt = Date.now();
+		c.set(requestIdContextKey, requestId);
+		c.set(requestStartedAtContextKey, startedAt);
+		return startActiveSpan(tracer, `${method} ${getRouteLabel(c.req.routePath)}`, async (span) => {
+			const spanContext = span.spanContext();
+			const traceIdentifiers = getTraceIdentifiersFromContext(spanContext.traceId, spanContext.spanId);
+			span.setAttribute("http.method", method);
+			span.setAttribute("http.target", path);
+			span.setAttribute("http.request_id", requestId);
+			await runWithLogContext({
+				component: parameters.component,
+				request_id: requestId,
+				...traceIdentifiers,
+				method
+			}, async () => {
+				await next();
+				const statusCode = c.res.status;
+				const durationMs = Math.max(Date.now() - startedAt, 0);
+				const routeLabel = getRouteLabel(c.req.routePath);
+				span.updateName(`${method} ${routeLabel}`);
+				span.setAttribute("http.route", routeLabel);
+				span.setAttribute("http.status_code", statusCode);
+				if (statusCode >= 500) span.setStatus({ code: SpanStatusCode.ERROR });
+				c.header(parameters.requestIdHeader, requestId);
+				getLogger().info({
+					event: HTTP_REQUEST_COMPLETED,
+					msg: "HTTP request completed",
+					status_code: statusCode,
+					duration_ms: durationMs,
+					route: routeLabel
+				});
+			});
+		});
+	};
+}
+/**
+* Build a shared unhandled error handler that logs structured failures and serializes payload errors.
+* @param parameters - Error logging configuration.
+* @returns Hono error handler.
+*/
+function createObservabilityErrorHandler(parameters) {
+	return (err, c) => {
+		const baseFailure = parameters.toFailurePayload(err);
+		const requestId = resolveRequestId(readContextString(c.get(requestIdContextKey)) ?? c.req.header(parameters.requestIdHeader));
+		const routeTemplate = getRouteLabel(c.req.routePath);
+		const adaptedFailure = parameters.adaptFailurePayload?.({
+			err,
+			failure: baseFailure,
+			method: c.req.method,
+			route: routeTemplate
+		});
+		const responseStatusCode = adaptedFailure?.statusCode ?? baseFailure.statusCode;
+		const startedAt = readContextNumber(c.get(requestStartedAtContextKey)) ?? Date.now();
+		const durationMs = Math.max(Date.now() - startedAt, 0);
+		const activeSpan = trace.getActiveSpan();
+		if (activeSpan) {
+			activeSpan.recordException(err);
+			if (responseStatusCode >= 500) activeSpan.setStatus({ code: SpanStatusCode.ERROR });
+			else activeSpan.setStatus({ code: SpanStatusCode.UNSET });
+			activeSpan.setAttribute("http.route", routeTemplate);
+			activeSpan.setAttribute("http.status_code", responseStatusCode);
+			activeSpan.setAttribute("http.request_id", requestId);
+		}
+		const traceIdentifiers = getActiveTraceIdentifiers();
+		getLogger().error({
+			event: HTTP_REQUEST_FAILED,
+			msg: "HTTP request failed",
+			err,
+			component: parameters.component,
+			method: c.req.method,
+			route: routeTemplate,
+			request_id: requestId,
+			status_code: responseStatusCode,
+			duration_ms: durationMs,
+			...traceIdentifiers
+		});
+		c.header(parameters.requestIdHeader, requestId);
+		if (adaptedFailure) return c.text(adaptedFailure.body, adaptedFailure.statusCode, {
+			"Content-Type": adaptedFailure.contentType,
+			...adaptedFailure.headers
+		});
+		return c.json(baseFailure.body, baseFailure.statusCode);
+	};
+}
+/**
+* Convert a Hono route path into a stable request route label.
+* @param routePath - Hono route path from the request.
+* @returns Route label for logs and trace attributes.
+*/
+function getRouteLabel(routePath) {
+	const candidate = routePath?.trim();
+	if (candidate && candidate.length > 0) return candidate;
+	return unmatchedRouteLabel;
+}
+/**
+* Resolve a request ID from incoming headers and generate one when missing/invalid.
+* @param value - Incoming header value.
+* @returns Stable request ID value.
+*/
+function resolveRequestId(value) {
+	const candidate = value?.trim();
+	if (candidate && candidate.length <= 128) return candidate;
+	return randomUUID();
+}
+function readContextString(value) {
+	return typeof value === "string" ? value : void 0;
+}
+function readContextNumber(value) {
+	return typeof value === "number" ? value : void 0;
+}
+
 //#endregion
 //#region src/api/Schema/BookResponse.ts
 var BookResponse_exports = /* @__PURE__ */ __exportAll({ from: () => from$5 });
@@ -6202,7 +6906,7 @@ const offerExample = {
 		receiver_if_maker_is_seller: "0x7b093658BE7f90B63D7c359e8f408e503c2D9401"
 	},
 	offer_hash: "0xac4bd8318ec914f89f8af913f162230575b0ac0696a19256bc12138c5cfe1427",
-	obligation_id: "0x25690ae1aee324a005be565f3bcdd16dbf8daf7969b26c181c8b8f467dad9abc",
+	obligation_id: "0x25690ae1aee324a005be565f3bcdd16dbf8daf79",
 	chain_id: 1,
 	consumed: "0",
 	takeable: "369216000000000000000000",
@@ -6774,7 +7478,7 @@ const positionExample = {
 	chain_id: 1,
 	contract: "0xC9A9C45C0eB717f8b5F193Af6bAa05A1c0Ac5078",
 	user: "0x7b093658BE7f90B63D7c359e8f408e503c2D9401",
-	obligation_id: "0x12590ae1aee324a005be565f3bcdd16dbf8daf7969b26c181c8b8f467dad9f67",
+	obligation_id: "0x12590ae1aee324a005be565f3bcdd16dbf8daf79",
 	reserved: "200000000000000000000",
 	block_number: 21345678
 };
@@ -7459,11 +8163,14 @@ function isValidBase64urlJson(val) {
 function isValidOfferHashCursor(val) {
 	return /^0x[a-f0-9]{64}$/i.test(val);
 }
+function isValidObligationIdCursor(val) {
+	return /^0x[a-f0-9]{40}$/i.test(val);
+}
 function isValidOfferCursor(val) {
 	const [hash, obligationId, ...rest] = val.split(":");
 	if (rest.length !== 0) return false;
 	if (!hash || !obligationId) return false;
-	return isValidOfferHashCursor(hash) && isValidOfferHashCursor(obligationId);
+	return isValidOfferHashCursor(hash) && isValidObligationIdCursor(obligationId);
 }
 const csvArray = (schema) => z$1.preprocess((value) => {
 	if (value === void 0) return void 0;
@@ -7492,10 +8199,14 @@ const ConfigRuleTypes = z$1.enum([
 	"callback",
 	"loan_token",
 	"collateral_token",
-	"oracle"
+	"oracle",
+	"group_consistency",
+	"group_immutability",
+	"max_collaterals",
+	"min_duration"
 ]);
 const GetConfigRulesQueryParams = z$1.object({
-	cursor: z$1.string().regex(/^(maturity|callback|loan_token|collateral_token|oracle):[1-9]\d*:.+$/, { message: "Cursor must be in the format type:chain_id:<value>" }).optional().meta({
+	cursor: z$1.string().regex(/^(maturity|callback|loan_token|collateral_token|oracle|group_consistency|group_immutability|max_collaterals|min_duration):[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"
 	}),
@@ -7535,9 +8246,9 @@ const GetOffersQueryParams = PaginationQueryParams.omit({ cursor: true }).extend
 		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({
+	obligation_id: z$1.string().regex(/^0x[a-fA-F0-9]{40}$/, { error: "Obligation id must be a valid 20-byte hex string" }).transform((val) => val.toLowerCase()).optional().meta({
 		description: "Offers obligation id. Required when not using maker.",
-		example: "0x1234567890123456789012345678901234567890123456789012345678901234"
+		example: "0x1234567890123456789012345678901234567890"
 	}),
 	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.",
@@ -7622,9 +8333,9 @@ const GetObligationsQueryParams = z$1.object({
 		example: "-ask,bid,maturity"
 	})
 });
-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({
+const GetObligationParams = z$1.object({ obligation_id: z$1.string({ error: "Obligation id is required and must be a valid 20-byte hex string" }).regex(/^0x[a-fA-F0-9]{40}$/, { error: "Obligation id must be a valid 20-byte hex string" }).transform((val) => val.toLowerCase()).meta({
 	description: "Obligation id",
-	example: "0x1234567890123456789012345678901234567890123456789012345678901234"
+	example: "0x1234567890123456789012345678901234567890"
 }) });
 /** Validate a book cursor format: {side, lastTick, offersCursor} */
 function isValidBookCursor(cursorString) {
@@ -7659,9 +8370,9 @@ const HealthQueryParams = z$1.object({ strict: z$1.enum([
 }) });
 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({
+	obligation_id: z$1.string({ error: "Obligation id is required and must be a valid 20-byte hex string" }).regex(/^0x[a-fA-F0-9]{40}$/, { error: "Obligation id must be a valid 20-byte hex string" }).transform((val) => val.toLowerCase()).meta({
 		description: "Obligation id",
-		example: "0x1234567890123456789012345678901234567890123456789012345678901234"
+		example: "0x1234567890123456789012345678901234567890"
 	}),
 	side: z$1.enum(["buy", "sell"]).meta({
 		description: "Side of the book (buy or sell).",
@@ -7745,9 +8456,11 @@ async function getBook(params, db) {
 	} 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
+			event: API_GET_BOOK_FAILED,
+			msg: "Failed to get book",
+			endpoint: "get_book",
+			obligation_id: query.obligation_id,
+			side: query.side
 		});
 		return failure(err);
 	}
@@ -7935,6 +8648,7 @@ const oracles = {
 	],
 	[ChainId["ETHEREUM-VIRTUAL-TESTNET"].toString()]: [
 		"0xDddd770BADd886dF3864029e4B377B5F6a2B6b83",
+		"0xEeee770BADd886dF3864029e4B377B5F6a2B6b83",
 		"0x9CB3f4276bcD149b3668e1a645a964bC12877b89",
 		"0x48F7E36EB6B826B2dF4B2E630B62Cd25e89E40e2",
 		"0x6Eb9F4128CeBc8B885A4d8562Db1Addf097f7348",
@@ -7943,6 +8657,7 @@ const oracles = {
 	],
 	[ChainId.ANVIL.toString()]: [
 		"0xDddd770BADd886dF3864029e4B377B5F6a2B6b83",
+		"0xEeee770BADd886dF3864029e4B377B5F6a2B6b83",
 		"0x9CB3f4276bcD149b3668e1a645a964bC12877b89",
 		"0x48F7E36EB6B826B2dF4B2E630B62Cd25e89E40e2",
 		"0x6Eb9F4128CeBc8B885A4d8562Db1Addf097f7348",
@@ -7953,19 +8668,23 @@ const oracles = {
 const configs = {
 	ethereum: {
 		callbacks: [{ type: Type$1.BuyWithEmptyCallback }, { type: Type$1.SellWithEmptyCallback }],
-		maturities: [MaturityType.EndOfWeek, MaturityType.EndOfNextWeek]
+		maturities: [MaturityType.EndOfWeek, MaturityType.EndOfNextWeek],
+		minDuration: 10
 	},
 	base: {
 		callbacks: [{ type: Type$1.BuyWithEmptyCallback }, { type: Type$1.SellWithEmptyCallback }],
-		maturities: [MaturityType.EndOfWeek, MaturityType.EndOfNextWeek]
+		maturities: [MaturityType.EndOfWeek, MaturityType.EndOfNextWeek],
+		minDuration: 10
 	},
 	"ethereum-virtual-testnet": {
 		callbacks: [{ type: Type$1.BuyWithEmptyCallback }, { type: Type$1.SellWithEmptyCallback }],
-		maturities: [MaturityType.EndOfWeek, MaturityType.EndOfNextWeek]
+		maturities: [MaturityType.EndOfWeek, MaturityType.EndOfNextWeek],
+		minDuration: 10
 	},
 	anvil: {
 		callbacks: [{ type: Type$1.BuyWithEmptyCallback }, { type: Type$1.SellWithEmptyCallback }],
-		maturities: [MaturityType.EndOfWeek, MaturityType.EndOfNextWeek]
+		maturities: [MaturityType.EndOfWeek, MaturityType.EndOfNextWeek],
+		minDuration: 10
 	}
 };
 
@@ -7979,7 +8698,8 @@ const configs = {
 function buildConfigRules(chains) {
 	const rules = [];
 	for (const chain of chains) {
-		const maturities = configs[chain.name].maturities ?? [];
+		const config = configs[chain.name];
+		const maturities = config.maturities ?? [];
 		for (const maturityName of maturities) rules.push({
 			type: "maturity",
 			chain_id: chain.id,
@@ -8004,6 +8724,26 @@ function buildConfigRules(chains) {
 			chain_id: chain.id,
 			address: normalizeAddress(address)
 		});
+		rules.push({
+			type: "group_consistency",
+			chain_id: chain.id,
+			description: "All offers in a group must have the same loan token, assets amount, and side (buy/sell)"
+		});
+		rules.push({
+			type: "group_immutability",
+			chain_id: chain.id,
+			description: "Cannot add offers to a group after group creation"
+		});
+		rules.push({
+			type: "max_collaterals",
+			chain_id: chain.id,
+			max: 128
+		});
+		if (config.minDuration != null) rules.push({
+			type: "min_duration",
+			chain_id: chain.id,
+			min_seconds: config.minDuration
+		});
 	}
 	rules.sort(compareConfigRules);
 	return rules;
@@ -8033,6 +8773,22 @@ function buildConfigRulesChecksum(rules) {
 			hash.update(`oracle:${rule.chain_id}:${rule.address}\n`);
 			continue;
 		}
+		if (rule.type === "group_consistency") {
+			hash.update(`group_consistency:${rule.chain_id}\n`);
+			continue;
+		}
+		if (rule.type === "group_immutability") {
+			hash.update(`group_immutability:${rule.chain_id}\n`);
+			continue;
+		}
+		if (rule.type === "max_collaterals") {
+			hash.update(`max_collaterals:${rule.chain_id}:${rule.max}\n`);
+			continue;
+		}
+		if (rule.type === "min_duration") {
+			hash.update(`min_duration:${rule.chain_id}:${rule.min_seconds}\n`);
+			continue;
+		}
 		hash.update(`loan_token:${rule.chain_id}:${rule.address}\n`);
 	}
 	return hash.digest("hex");
@@ -8051,6 +8807,8 @@ function compareConfigRules(left, right) {
 	if (left.type === "loan_token" && right.type === "loan_token") return left.address.localeCompare(right.address);
 	if (left.type === "collateral_token" && right.type === "collateral_token") return left.address.localeCompare(right.address);
 	if (left.type === "oracle" && right.type === "oracle") return left.address.localeCompare(right.address);
+	if (left.type === "max_collaterals" && right.type === "max_collaterals") return left.max - right.max;
+	if (left.type === "min_duration" && right.type === "min_duration") return left.min_seconds - right.min_seconds;
 	return 0;
 }
 
@@ -8097,6 +8855,10 @@ function formatCursor$2(rule) {
 	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()}`;
 	if (rule.type === "collateral_token") return `collateral_token:${rule.chain_id}:${rule.address.toLowerCase()}`;
+	if (rule.type === "group_consistency") return `group_consistency:${rule.chain_id}:_`;
+	if (rule.type === "group_immutability") return `group_immutability:${rule.chain_id}:_`;
+	if (rule.type === "max_collaterals") return `max_collaterals:${rule.chain_id}:${rule.max}`;
+	if (rule.type === "min_duration") return `min_duration:${rule.chain_id}:${rule.min_seconds}`;
 	return `loan_token:${rule.chain_id}:${rule.address.toLowerCase()}`;
 }
 function parseCursor$2(cursor) {
@@ -8138,6 +8900,34 @@ function parseCursor$2(cursor) {
 			address: parseAddress(addressValue, "Cursor address")
 		};
 	}
+	if (type === "group_consistency") return {
+		type,
+		chain_id,
+		description: "All offers in a group must have the same loan token, assets amount, and side (buy/sell)"
+	};
+	if (type === "group_immutability") return {
+		type,
+		chain_id,
+		description: "Cannot add offers to a group after group creation"
+	};
+	if (type === "max_collaterals") {
+		const maxValue = Number.parseInt(rest[0] ?? "", 10);
+		if (!Number.isFinite(maxValue) || maxValue < 0) throw new BadRequestError$1("Cursor must be in the format max_collaterals:chain_id:max");
+		return {
+			type,
+			chain_id,
+			max: maxValue
+		};
+	}
+	if (type === "min_duration") {
+		const minSecondsValue = Number.parseInt(rest[0] ?? "", 10);
+		if (!Number.isFinite(minSecondsValue) || minSecondsValue < 0) throw new BadRequestError$1("Cursor must be in the format min_duration:chain_id:min_seconds");
+		return {
+			type,
+			chain_id,
+			min_seconds: minSecondsValue
+		};
+	}
 	throw new BadRequestError$1("Cursor has an invalid rule type");
 }
 function findStartIndex(rules, cursor) {
@@ -8156,7 +8946,7 @@ function parseAddress(address, label) {
 	return address.toLowerCase();
 }
 function isConfigRuleType(value) {
-	return value === "maturity" || value === "callback" || value === "loan_token" || value === "collateral_token" || value === "oracle";
+	return value === "maturity" || value === "callback" || value === "loan_token" || value === "collateral_token" || value === "oracle" || value === "group_consistency" || value === "group_immutability" || value === "max_collaterals" || value === "min_duration";
 }
 function isMaturityType(value) {
 	return Object.values(MaturityType).includes(value);
@@ -8261,7 +9051,7 @@ async function getHealth(query, db, chainRegistry) {
 	try {
 		const parsed = safeParse("get_health", query);
 		if (!parsed.success) return failure(parsed.error);
-		const snapshot = await create$17({
+		const snapshot = await create$18({
 			db,
 			chainRegistry
 		}).getSnapshot();
@@ -8278,9 +9068,9 @@ async function getHealth(query, db, chainRegistry) {
 	} 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
+			event: API_GET_HEALTH_FAILED,
+			msg: "Failed to get health status",
+			endpoint: "get_health"
 		});
 		return failure(err);
 	}
@@ -8290,7 +9080,7 @@ async function getHealthChains(query, db, healthClients, chainRegistry) {
 	try {
 		const parsed = safeParse("get_health_chains", query);
 		if (!parsed.success) return failure(parsed.error);
-		const snapshot = await create$17({
+		const snapshot = await create$18({
 			db,
 			healthClients,
 			chainRegistry
@@ -8310,9 +9100,9 @@ async function getHealthChains(query, db, healthClients, chainRegistry) {
 	} 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
+			event: API_GET_HEALTH_CHAINS_FAILED,
+			msg: "Failed to get health status for chains",
+			endpoint: "get_health_chains"
 		});
 		return failure(err);
 	}
@@ -8322,7 +9112,7 @@ async function getHealthCollectors(query, db, chainRegistry) {
 	try {
 		const parsed = safeParse("get_health_collectors", query);
 		if (!parsed.success) return failure(parsed.error);
-		const snapshot = await create$17({
+		const snapshot = await create$18({
 			db,
 			chainRegistry
 		}).getSnapshot();
@@ -8343,14 +9133,99 @@ async function getHealthCollectors(query, db, chainRegistry) {
 	} 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
+			event: API_GET_HEALTH_COLLECTORS_FAILED,
+			msg: "Failed to get health status for collectors",
+			endpoint: "get_health_collectors"
 		});
 		return failure(err);
 	}
 }
 
+//#endregion
+//#region src/api/Metrics.ts
+const COLLECTOR_LAG_BLOCKS_METRIC = "router_collector_lag_blocks";
+const COLLECTOR_BLOCK_NUMBER_METRIC = "router_collector_block_number";
+const CHAIN_BLOCK_NUMBER_METRIC = "router_chain_block_number";
+/**
+* Create a metrics service that renders collector and chain metrics in Prometheus format.
+* @param parameters - Service dependencies. {@link MetricsServiceParameters}
+* @returns The metrics service. {@link MetricsService}
+*/
+function create$17(parameters) {
+	const { db, chainRegistry } = parameters;
+	const healthService = create$18({
+		db,
+		chainRegistry
+	});
+	return { async getPrometheusMetrics() {
+		const snapshot = await healthService.getSnapshot();
+		return renderPrometheusMetrics({
+			collectors: snapshot.collectors,
+			chains: snapshot.chains
+		});
+	} };
+}
+/**
+* Render Prometheus exposition text for collector and chain synchronization metrics.
+* @param parameters - Snapshot state to expose. {@link RenderPrometheusMetricsParameters}
+* @returns Prometheus metrics text.
+*/
+function renderPrometheusMetrics(parameters) {
+	const lines = [
+		`# HELP ${COLLECTOR_LAG_BLOCKS_METRIC} Collector lag in blocks behind the indexed chain head.`,
+		`# TYPE ${COLLECTOR_LAG_BLOCKS_METRIC} gauge`,
+		`# HELP ${COLLECTOR_BLOCK_NUMBER_METRIC} Latest indexed block number per collector.`,
+		`# TYPE ${COLLECTOR_BLOCK_NUMBER_METRIC} gauge`,
+		`# HELP ${CHAIN_BLOCK_NUMBER_METRIC} Latest indexed block number per chain.`,
+		`# TYPE ${CHAIN_BLOCK_NUMBER_METRIC} gauge`
+	];
+	lines.push(`${COLLECTOR_LAG_BLOCKS_METRIC}{collector="__merge_alarm__",chain_id="0"} 9999`);
+	const collectors = [...parameters.collectors].sort((left, right) => left.chainId === right.chainId ? left.name.localeCompare(right.name) : left.chainId - right.chainId);
+	for (const collector of collectors) {
+		const labels = renderCollectorLabels({
+			collector: collector.name,
+			chainId: collector.chainId
+		});
+		if (collector.initialized && collector.lag !== null) lines.push(`${COLLECTOR_LAG_BLOCKS_METRIC}${labels} ${renderGaugeValue(collector.lag)}`);
+		if (collector.initialized && collector.blockNumber !== null) lines.push(`${COLLECTOR_BLOCK_NUMBER_METRIC}${labels} ${renderGaugeValue(collector.blockNumber)}`);
+	}
+	const chains = [...parameters.chains].sort((left, right) => left.chainId - right.chainId);
+	for (const chain of chains) {
+		if (!chain.initialized || chain.localBlockNumber === null) continue;
+		const labels = renderChainLabels({ chainId: chain.chainId });
+		lines.push(`${CHAIN_BLOCK_NUMBER_METRIC}${labels} ${renderGaugeValue(chain.localBlockNumber)}`);
+	}
+	return `${lines.join("\n")}\n`;
+}
+function renderCollectorLabels(parameters) {
+	return `{collector="${escapeLabelValue(parameters.collector)}",chain_id="${parameters.chainId}"}`;
+}
+function renderChainLabels(parameters) {
+	return `{chain_id="${parameters.chainId}"}`;
+}
+function renderGaugeValue(value) {
+	if (!Number.isFinite(value)) throw new Error(`Metrics value must be finite, received ${value}`);
+	return `${value}`;
+}
+function escapeLabelValue(value) {
+	return value.replace(/\\/g, "\\\\").replace(/\n/g, "\\n").replace(/"/g, "\\\"");
+}
+
+//#endregion
+//#region src/api/Controllers/getMetrics.ts
+/**
+* Get router synchronization metrics in Prometheus exposition format.
+* @param db - Database instance. {@link Database.Database}
+* @param chainRegistry - Optional chain registry used to scope expected chains.
+* @returns Prometheus exposition payload.
+*/
+async function getMetrics(db, chainRegistry) {
+	return await create$17({
+		db,
+		chainRegistry
+	}).getPrometheusMetrics();
+}
+
 //#endregion
 //#region src/database/readers/ObligationsListing.ts
 const SORT_FIELDS = [
@@ -8359,7 +9234,7 @@ const SORT_FIELDS = [
 	"bid",
 	"maturity"
 ];
-const CURSOR_ID_REGEX = /^0x[a-f0-9]{64}$/i;
+const CURSOR_ID_REGEX = /^0x[a-f0-9]{40}$/i;
 const INT32_MIN = -2147483648;
 const INT32_MAX = 2147483647;
 const INT32_MAX_BIGINT = BigInt(INT32_MAX);
@@ -8407,7 +9282,7 @@ function create$16(parameters) {
 			bidTick: sql`MAX(${bestBidTick.bidTick})`.as("bid_tick"),
 			ask: sql`COALESCE(MAX(${bestAskTick.askTick}) + 1, 0)`.as("ask"),
 			bid: sql`COALESCE(MAX(${bestBidTick.bidTick}) + 1, 0)`.as("bid")
-		}).from(obligationIdKeys).innerJoin(obligations, eq(obligationIdKeys.obligationKey, obligations.obligationKey)).innerJoin(obligationCollateralsV2, eq(obligations.obligationKey, obligationCollateralsV2.obligationKey)).leftJoinLateral(bestAskTick, sql`true`).leftJoinLateral(bestBidTick, sql`true`).groupBy(obligationIdKeys.obligationId, obligationIdKeys.chainId, obligations.loanToken, obligations.maturity).where(and(ids !== void 0 && ids.length > 0 ? inArray(obligationIdKeys.obligationId, ids) : void 0, chainIds !== void 0 && chainIds.length > 0 ? inArray(obligationIdKeys.chainId, chainIds) : void 0, loanTokenFilter, maturities !== void 0 && maturities.length > 0 ? inArray(obligations.maturity, maturities) : gte(obligations.maturity, now$3), collateralFilter)).as("obligations_with_quotes");
+		}).from(obligationIdKeys).innerJoin(obligations, eq(obligationIdKeys.obligationKey, obligations.obligationKey)).innerJoin(obligationCollateralsV2, eq(obligations.obligationKey, obligationCollateralsV2.obligationKey)).leftJoinLateral(bestAskTick, sql`true`).leftJoinLateral(bestBidTick, sql`true`).groupBy(obligationIdKeys.obligationId, obligationIdKeys.chainId, obligations.loanToken, obligations.maturity).where(and(ids !== void 0 && ids.length > 0 ? inArray(obligationIdKeys.obligationId, ids) : void 0, chainIds !== void 0 && chainIds.length > 0 ? inArray(obligationIdKeys.chainId, chainIds) : void 0, loanTokenFilter, maturities !== void 0 && maturities.length > 0 ? inArray(obligations.maturity, maturities) : void 0, collateralFilter)).as("obligations_with_quotes");
 		const sortColumns = {
 			id: obligationsWithQuotes.obligationId,
 			ask: obligationsWithQuotes.ask,
@@ -8609,9 +9484,10 @@ async function getObligation(params, db) {
 		const payloadError = toPayloadError$1(err);
 		logger.error({
 			err: payloadError,
-			msg: "Error get obligation",
-			errorMessage: payloadError instanceof Error ? payloadError.message : String(payloadError),
-			errorStack: payloadError instanceof Error ? payloadError.stack : void 0
+			event: API_GET_OBLIGATION_FAILED,
+			msg: "Failed to get obligation",
+			endpoint: "get_obligation",
+			obligation_id: query.obligation_id
 		});
 		return failure(payloadError);
 	}
@@ -8650,28 +9526,278 @@ async function getObligations$1(queryParameters, db) {
 		const payloadError = toPayloadError(err);
 		logger.error({
 			err: payloadError,
-			msg: "Error get obligations",
-			errorMessage: payloadError instanceof Error ? payloadError.message : String(payloadError),
-			errorStack: payloadError instanceof Error ? payloadError.stack : void 0
+			event: API_GET_OBLIGATIONS_FAILED,
+			msg: "Failed to get obligations",
+			endpoint: "get_obligations",
+			sort: query.sort,
+			has_cursor: query.cursor != null,
+			limit: query.limit ?? null
 		});
 		return failure(payloadError);
 	}
 }
 
 //#endregion
-//#region src/database/constants.ts
+//#region src/database/domains/OfferFormulas.ts
+const IDENTIFIER_PATTERN = /^[a-z_][a-z0-9_]*$/;
 /**
-* Default batch size for bulk database inserts.
+* Assert that a value is a valid SQL identifier (lowercase alphanumeric + underscores).
+* @param value - The value to validate.
+* @param label - A descriptive label for error messages.
+*/
+function assertIdentifier(value, label) {
+	if (!IDENTIFIER_PATTERN.test(value)) throw new Error(`Invalid SQL identifier for ${label}: "${value}". Must match ${IDENTIFIER_PATTERN}.`);
+}
+/**
+* Single position's balance contribution in loan-token units.
 *
-* 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.
+* - **ERC20 / DEBT_OF**: both price and lltv are NULL (no oracle/obligation
+*   join match). The CASE falls through to the ELSE branch producing
+*   `balance * 1e36 * 1e18 / 1e54 = balance` (identity).
+* - **COLLATERAL_OF with price**: real price and lltv from oracle/obligation
+*   JOINs → `balance * price * lltv / 1e54`.
+* - **COLLATERAL_OF with NULL price**: oracle row exists but price has not
+*   been collected yet. lltv IS NOT NULL so COALESCE(price, 0) yields 0,
+*   treating the position as unavailable until the price is fetched.
 *
-* Our largest batched insert is into the `offers` table with 15 columns.
-* 15 cols × 4,000 rows = 60,000 parameters, safely under 65,535.
+* @param balance - Position balance column/expression.
+* @param price - Oracle price column/expression.
+* @param lltv - Obligation collateral LLTV column/expression.
 */
-const DEFAULT_BATCH_SIZE$1 = 4e3;
+function offerBalanceTerm(balance, price, lltv) {
+	return sql`COALESCE(${balance}::numeric, 0) * CASE WHEN ${lltv}::numeric IS NOT NULL THEN COALESCE(${price}::numeric, 0) ELSE 10::numeric ^ 36 END * COALESCE(${lltv}::numeric, 10::numeric ^ 18) / (10::numeric ^ 54)`;
+}
+/**
+* Lot balance: how much liquidity is available to a lot.
+* @param offerBalance - Aggregated offer balance for the position (from offer_balances CTE).
+* @param offset - Sum of offsets for this position+obligation.
+* @param positionConsumed - Sum of consumed capacity across groups for this position+obligation.
+* @param lotLower - Lot lower bound.
+* @param lotUpper - Lot upper bound.
+* @param consumed - Group consumed amount (in loan-token terms).
+* @param assets - Offer assets (for lot_consumed conversion).
+*/
+function lotBalance(offerBalance, offset, positionConsumed, lotLower, lotUpper, consumed, assets) {
+	const lotSize = sql`(COALESCE(${lotUpper}::numeric, 0) - COALESCE(${lotLower}::numeric, 0))`;
+	return sql`GREATEST(0, LEAST(COALESCE(${offerBalance}, 0) + COALESCE(${offset}, 0) + COALESCE(${positionConsumed}, 0) - COALESCE(${lotLower}::numeric, 0), ${lotSize} - ${sql`CASE WHEN ${assets}::numeric > 0 THEN COALESCE(${consumed}::numeric, 0) * ${lotSize} / ${assets}::numeric ELSE 0 END`}))`;
+}
+/**
+* Callback contribution: amount contributed by one callback in loan terms.
+* Returns 0 when lot_lower IS NULL (no lot exists for this callback).
+* @param lotBalance - Computed lot balance.
+* @param lotLower - Lot lower bound (NULL means no lot exists).
+*/
+function contribution(lotBalance, lotLower) {
+	return sql`CASE WHEN ${lotLower} IS NULL THEN 0 ELSE ${lotBalance} END`;
+}
+/**
+* Unified takeable for buy and sell offers.
+* @param assets - Offer assets.
+* @param consumed - Group consumed amount.
+* @param available - Total available from callbacks/positions.
+*/
+function takeable(assets, consumed, available) {
+	return sql`GREATEST(0, LEAST(${assets}::numeric - ${consumed}::numeric, ${available}))`;
+}
+/**
+* Build a comma-prefixed SQL fragment containing 8 CTEs that compute
+* `offer_available(hash, obligation_id, available)`.
+*
+* Append the result inside a `WITH` clause after the caller's own CTEs.
+*
+* Reserved CTE names (callers must not reuse):
+* `group_winners`, `relevant_positions`, `position_offsets`,
+* `position_consumed`, `offer_balances`, `callback_contributions`,
+* `callback_loan_contribution`, `offer_available`.
+*
+* @param params - {@link OfferCTEParams}
+*/
+function offerAvailabilityCTEs(params) {
+	assertIdentifier(params.sourceTable, "sourceTable");
+	const groupScope = params.groupScope ?? params.sourceTable;
+	if (params.groupScope !== void 0) assertIdentifier(groupScope, "groupScope");
+	const source = sql.raw(params.sourceTable);
+	const scope = sql.raw(groupScope);
+	const { now } = params;
+	return sql`
+    , group_winners AS (
+      SELECT DISTINCT ON (o.group_chain_id, o.group_maker, o.group_group, o.obligation_id, o.buy)
+        o.group_chain_id, o.group_maker, o.group_group, o.obligation_id, o.buy, o.assets
+      FROM ${offers} o
+      LEFT JOIN ${validations} v
+        ON v.offer_hash = o.hash
+        AND v.obligation_id = o.obligation_id
+      LEFT JOIN ${status} s
+        ON s.id = v.status_id
+      WHERE (o.group_chain_id, o.group_maker, o.group_group) IN (
+        SELECT DISTINCT gs.group_chain_id, gs.group_maker, gs.group_group FROM ${scope} gs
+      )
+        AND o.expiry   > ${now}
+        AND o.maturity > ${now}
+        AND o.start   <= ${now}
+        AND (s.code IS NULL OR s.code = ${Status.VALID})
+      ORDER BY
+        o.group_chain_id, o.group_maker, o.group_group, o.obligation_id, o.buy,
+        CASE WHEN o.buy THEN -o.tick ELSE o.tick END ASC,
+        o.block_number ASC, o.assets DESC, o.hash ASC
+    ),
+    relevant_positions AS (
+      SELECT DISTINCT c.position_chain_id, c.position_contract, c.position_user
+      FROM ${source} src
+      JOIN ${offersCallbacks} oc
+        ON oc.offer_hash = src.hash AND oc.obligation_id = src.obligation_id
+      JOIN ${callbacks} c ON c.id = oc.callback_id
+    ),
+    position_offsets AS (
+      SELECT chain_id, "user", contract, obligation_id,
+        SUM(value::numeric) AS total_offset
+      FROM ${offsets}
+      WHERE (chain_id, contract, "user") IN (
+        SELECT position_chain_id, position_contract, position_user FROM relevant_positions
+      )
+      GROUP BY chain_id, "user", contract, obligation_id
+    ),
+    position_consumed AS (
+      SELECT
+        l.chain_id, l.contract, l."user", l.obligation_id, wo.buy,
+        SUM(
+          CASE
+            WHEN wo.assets::numeric > 0
+            THEN COALESCE(g.consumed::numeric, 0) * (l.upper::numeric - l.lower::numeric) / wo.assets::numeric
+            ELSE 0
+          END
+        ) AS consumed
+      FROM ${lots} l
+      JOIN ${groups} g
+        ON g.chain_id = l.chain_id
+        AND g.maker = l."user"
+        AND g."group" = l."group"
+      JOIN group_winners wo
+        ON wo.group_chain_id = g.chain_id
+        AND wo.group_maker = g.maker
+        AND wo.group_group = g."group"
+        AND wo.obligation_id = l.obligation_id
+      GROUP BY l.chain_id, l.contract, l."user", l.obligation_id, wo.buy
+    ),
+    offer_balances AS (
+      SELECT
+        pos.chain_id, pos.contract, pos."user",
+        SUM(
+          ${offerBalanceTerm(sql`pos.balance`, sql`o.price`, sql`oc_col.lltv`)}
+        ) AS offer_balance
+      FROM ${positions} pos
+      LEFT JOIN ${obligationIdKeys} oik
+        ON oik.obligation_id = pos.contract
+      LEFT JOIN ${obligationCollateralsV2} oc_col
+        ON oc_col.obligation_key = oik.obligation_key
+        AND oc_col.asset = pos.asset
+      LEFT JOIN ${oracles$1} o
+        ON o.chain_id = pos.chain_id
+        AND o.address = oc_col.oracle_address
+      WHERE (pos.chain_id, pos.contract, pos."user") IN (
+        SELECT position_chain_id, position_contract, position_user FROM relevant_positions
+      )
+      GROUP BY pos.chain_id, pos.contract, pos."user"
+    ),
+    callback_contributions AS (
+      SELECT
+        src.hash,
+        src.obligation_id,
+        src.group_group,
+        src.consumed,
+        src.assets,
+        c.id AS callback_id,
+        c.position_chain_id,
+        c.position_contract,
+        c.position_user,
+        l.lower AS lot_lower,
+        l.upper AS lot_upper,
+        ${lotBalance(sql`vb.offer_balance`, sql`pos_offsets.total_offset`, sql`pc.consumed`, sql`l.lower`, sql`l.upper`, sql`src.consumed`, sql`src.assets`)} AS lot_balance
+      FROM ${source} src
+      LEFT JOIN ${offersCallbacks} oc
+        ON oc.offer_hash = src.hash
+        AND oc.obligation_id = src.obligation_id
+      LEFT JOIN ${callbacks} c ON c.id = oc.callback_id
+      LEFT JOIN ${lots} l
+        ON l.chain_id = c.position_chain_id
+        AND l.contract = c.position_contract
+        AND l."user" = c.position_user
+        AND l."group" = src.group_group
+        AND l.obligation_id = src.obligation_id
+      LEFT JOIN offer_balances vb
+        ON vb.chain_id = c.position_chain_id
+        AND vb.contract = c.position_contract
+        AND vb."user" = c.position_user
+      LEFT JOIN position_offsets pos_offsets
+        ON pos_offsets.chain_id = c.position_chain_id
+        AND pos_offsets.contract = c.position_contract
+        AND pos_offsets."user" = c.position_user
+        AND pos_offsets.obligation_id = src.obligation_id
+      LEFT JOIN position_consumed pc
+        ON pc.chain_id = c.position_chain_id
+        AND pc.contract = c.position_contract
+        AND pc."user" = c.position_user
+        AND pc.obligation_id = src.obligation_id
+        AND pc.buy = src.buy
+    ),
+    callback_loan_contribution AS (
+      SELECT cc.*,
+        ${contribution(sql`cc.lot_balance`, sql`cc.lot_lower`)} AS contribution_in_loan
+      FROM callback_contributions cc
+    ),
+    offer_available AS (
+      SELECT hash, obligation_id,
+        SUM(max_contribution) AS available
+      FROM (
+        SELECT hash, obligation_id, position_chain_id, position_contract, position_user,
+          MAX(contribution_in_loan) AS max_contribution
+        FROM callback_loan_contribution
+        WHERE callback_id IS NOT NULL
+        GROUP BY hash, obligation_id, position_chain_id, position_contract, position_user
+      ) per_position
+      GROUP BY hash, obligation_id
+    )`;
+}
+/**
+* Build a comma-prefixed SQL fragment containing 9 CTEs that compute
+* `offer_takeable(hash, obligation_id, available, takeable)`.
+*
+* Wraps {@link offerAvailabilityCTEs} and adds one CTE that LEFT JOINs
+* `offer_available` back to the source table, ensuring every source offer
+* appears (with `available = 0` when no callbacks exist).
+*
+* Reserved CTE names: all from {@link offerAvailabilityCTEs} plus `offer_takeable`.
+*
+* @param params - {@link OfferCTEParams}
+*/
+function offerTakeabilityCTEs(params) {
+	assertIdentifier(params.sourceTable, "sourceTable");
+	const source = sql.raw(params.sourceTable);
+	return sql`
+    ${offerAvailabilityCTEs(params)},
+    offer_takeable AS (
+      SELECT src.hash, src.obligation_id,
+        COALESCE(oa.available, 0) AS available,
+        ${takeable(sql`src.assets`, sql`src.consumed`, sql`COALESCE(oa.available, 0)`)} AS takeable
+      FROM ${source} src
+      LEFT JOIN offer_available oa ON oa.hash = src.hash AND oa.obligation_id = src.obligation_id
+    )`;
+}
+
+//#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
@@ -8866,9 +9992,10 @@ function create$15(config) {
 	};
 }
 const HEX_32$2 = /^0x[a-fA-F0-9]{64}$/;
+const HEX_20$2 = /^0x[a-fA-F0-9]{40}$/;
 function parseCursor$1(cursor) {
 	const [hash, obligationId] = cursor.split(":");
-	if (!hash || !obligationId || !HEX_32$2.test(hash) || !HEX_32$2.test(obligationId)) throw new Error("Invalid cursor format");
+	if (!hash || !obligationId || !HEX_32$2.test(hash) || !HEX_20$2.test(obligationId)) throw new Error("Invalid cursor format");
 	return {
 		hash: hash.toLowerCase(),
 		obligationId: obligationId.toLowerCase()
@@ -8997,7 +10124,8 @@ function toAttestationKey(offer) {
 //#endregion
 //#region src/api/Controllers/getOffers.ts
 /**
-* Query offers with computed consumed/available/takeable values.
+* Query offers for a maker with computed consumed/available/takeable values.
+* Uses the same CTE-based computation as Book.ts via shared OfferFormulas builders.
 * @param db - The database client. {@link Database.Core}
 * @param parameters - {@link GetOffersQueryParams}
 * @returns The offers with pagination cursor.
@@ -9006,149 +10134,129 @@ async function getOffersQuery(db, parameters) {
 	const limit = parameters?.limit ?? DEFAULT_LIMIT$3;
 	const rawCursor = parameters?.cursor;
 	const maker = parameters?.maker;
-	const cursor = maker && rawCursor !== void 0 && rawCursor !== null ? parseMakerCursor(rawCursor) : void 0;
+	if (!maker) throw new Error("getOffersQuery requires a maker parameter");
+	const cursor = rawCursor !== void 0 && rawCursor !== null ? parseMakerCursor(rawCursor) : void 0;
 	const now = Math.floor((Date.now() - 1) / 1e3);
-	const collateralsLateral = db.select({ collaterals: sql`COALESCE(
-        jsonb_agg(
-          jsonb_build_object(
-            'asset', ${obligationCollateralsV2.asset},
-            'oracle', ${obligationCollateralsV2.oracleAddress},
-            'lltv', ${obligationCollateralsV2.lltv}
-          )
-        ),
-        '[]'::jsonb
-      )`.as("collaterals") }).from(obligationCollateralsV2).where(eq(obligationCollateralsV2.obligationKey, obligationIdKeys.obligationKey)).as("collaterals_lateral");
-	const lotBalanceExpr = sql`GREATEST(0, LEAST(
-      COALESCE(${positions.balance}, 0)::numeric
-        + COALESCE((
-            SELECT SUM(${offsets.value}::numeric)
-            FROM ${offsets}
-            WHERE ${offsets.chainId} = ${callbacks.positionChainId}
-              AND LOWER(${offsets.contract}) = LOWER(${callbacks.positionContract})
-              AND LOWER(${offsets.user}) = LOWER(${callbacks.positionUser})
-          ), 0)
-        - COALESCE(${lots.lower}::numeric, 0),
-      (COALESCE(${lots.upper}::numeric, 0) - COALESCE(${lots.lower}::numeric, 0))
-        - CASE
-            WHEN ${offers.assets}::numeric > 0
-            THEN COALESCE(${groups.consumed}::numeric, 0)
-              * (COALESCE(${lots.upper}::numeric, 0) - COALESCE(${lots.lower}::numeric, 0))
-              / ${offers.assets}::numeric
-            ELSE 0
-          END
-    ))`;
-	const contributionExpr = sql`CASE
-      WHEN ${positions.asset} IS NULL OR ${lots.lower} IS NULL THEN 0
-      ELSE LEAST(COALESCE(${callbacks.amount}::numeric, ${lotBalanceExpr}), ${lotBalanceExpr})
-    END`;
-	const availableExpr = sql`COALESCE((
-      SELECT SUM(deduped.contribution)
-      FROM (
-        SELECT DISTINCT ON (
-          ${callbacks.positionChainId},
-          LOWER(${callbacks.positionContract}),
-          LOWER(${callbacks.positionUser})
-        )
-          ${contributionExpr} AS contribution
-        FROM ${offersCallbacks}
-        INNER JOIN ${callbacks} ON ${offersCallbacks.callbackId} = ${callbacks.id}
-        LEFT JOIN ${positions}
-          ON ${positions.chainId} = ${callbacks.positionChainId}
-          AND LOWER(${positions.contract}) = LOWER(${callbacks.positionContract})
-          AND LOWER(${positions.user}) = LOWER(${callbacks.positionUser})
-        LEFT JOIN ${lots}
-          ON ${lots.chainId} = ${callbacks.positionChainId}
-          AND LOWER(${lots.contract}) = LOWER(${callbacks.positionContract})
-          AND LOWER(${lots.user}) = LOWER(${callbacks.positionUser})
-          AND LOWER(${lots.group}) = LOWER(${offers.group})
-        WHERE ${offersCallbacks.offerHash} = ${offers.hash}
-          AND ${offersCallbacks.obligationId} = ${offers.obligationId}
-        ORDER BY
-          ${callbacks.positionChainId},
-          LOWER(${callbacks.positionContract}),
-          LOWER(${callbacks.positionUser}),
-          ${contributionExpr} DESC
-      ) deduped
-    ), 0)`;
-	const rows = (await db.select({
-		hash: offers.hash,
-		obligationId: offers.obligationId,
-		maker: offers.groupMaker,
-		assets: offers.assets,
-		obligationUnits: offers.obligationUnits,
-		obligationShares: offers.obligationShares,
-		consumed: groups.consumed,
-		tick: offers.tick,
-		maturity: offers.maturity,
-		expiry: offers.expiry,
-		start: offers.start,
-		group: offers.group,
-		session: offers.session,
-		buy: offers.buy,
-		chainId: obligationIdKeys.chainId,
-		loanToken: obligations.loanToken,
-		callbackAddress: offers.callbackAddress,
-		callbackData: offers.callbackData,
-		receiverIfMakerIsSeller: offers.receiverIfMakerIsSeller,
-		collaterals: collateralsLateral.collaterals,
-		blockNumber: offers.blockNumber,
-		available: sql`${availableExpr}::numeric`.as("available"),
-		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,
-                ${availableExpr}::numeric
-              )
-            END
-          ))`.as("takeable")
-	}).from(offers).innerJoin(obligationIdKeys, eq(offers.obligationId, obligationIdKeys.obligationId)).innerJoin(obligations, eq(obligationIdKeys.obligationKey, obligations.obligationKey)).innerJoin(groups, and(eq(offers.groupChainId, groups.chainId), eq(offers.groupMaker, groups.maker), eq(offers.group, groups.group))).innerJoinLateral(collateralsLateral, sql`true`).where(and(cursor !== void 0 ? cursor.obligationId === void 0 ? gt(offers.hash, cursor.hash) : or(gt(offers.hash, cursor.hash), and(eq(offers.hash, cursor.hash), gt(offers.obligationId, cursor.obligationId))) : 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,
-                      ${availableExpr}::numeric
-                    )
-                  END
-                ) > 0` : void 0)).orderBy(asc(offers.hash), asc(offers.obligationId)).limit(limit)).map((row) => {
-		const receiverIfMakerIsSeller = (row.receiverIfMakerIsSeller ?? row.maker).toLowerCase();
+	const rows = (await db.execute(sql`
+    WITH maker_offers AS (
+      SELECT
+        o.*,
+        g.consumed, oik.chain_id, obl.loan_token
+      FROM ${offers} o
+      JOIN ${groups} g
+        ON g.chain_id = o.group_chain_id
+        AND g.maker = o.group_maker
+        AND g."group" = o.group_group
+      JOIN ${obligationIdKeys} oik
+        ON oik.obligation_id = o.obligation_id
+      JOIN ${obligations} obl
+        ON obl.obligation_key = oik.obligation_key
+      WHERE o.group_maker = ${maker.toLowerCase()}
+        AND o.expiry >= ${now}
+        AND o.maturity >= ${now}
+        ${cursor !== void 0 ? sql`AND (o.hash, o.obligation_id) > (${cursor.hash}, ${cursor.obligationId})` : sql``}
+      ORDER BY o.hash ASC, o.obligation_id ASC
+      LIMIT ${limit}
+    ),
+    maker_groups AS (
+      SELECT DISTINCT o.group_chain_id, o.group_maker, o.group_group
+      FROM ${offers} o
+      WHERE o.group_maker = ${maker.toLowerCase()}
+        AND o.expiry >= ${now}
+        AND o.maturity >= ${now}
+    ),
+    collats AS MATERIALIZED (
+      SELECT oia.obligation_id,
+            COALESCE(jsonb_agg(jsonb_build_object(
+              'asset',  oc.asset,
+              'oracle', oc.oracle_address,
+              'lltv',   oc.lltv
+            ) ORDER BY oc.asset), '[]'::jsonb) AS collaterals
+      FROM ${obligationIdKeys} oia
+      JOIN ${obligationCollateralsV2} oc
+        ON oc.obligation_key = oia.obligation_key
+      WHERE oia.obligation_id IN (SELECT DISTINCT mo.obligation_id FROM maker_offers mo)
+      GROUP BY oia.obligation_id
+    )
+    ${offerTakeabilityCTEs({
+		sourceTable: "maker_offers",
+		groupScope: "maker_groups",
+		now
+	})}
+    SELECT
+      mo.hash,
+      mo.obligation_id,
+      mo.group_maker,
+      mo.assets,
+      mo.obligation_units,
+      mo.obligation_shares,
+      mo.consumed,
+      mo.tick,
+      mo.maturity,
+      mo.expiry,
+      mo.start,
+      mo.group_group AS "group",
+      mo.buy,
+      mo.chain_id,
+      mo.loan_token,
+      mo.callback_address,
+      mo.callback_data,
+      mo.receiver_if_maker_is_seller,
+      mo.block_number,
+      mo.session,
+      COALESCE(ot.available, 0) AS available,
+      COALESCE(ot.takeable, 0) AS takeable,
+      c.collaterals
+    FROM maker_offers mo
+    LEFT JOIN offer_takeable ot
+      ON ot.hash = mo.hash AND ot.obligation_id = mo.obligation_id
+    LEFT JOIN collats c ON c.obligation_id = mo.obligation_id
+    ORDER BY mo.hash ASC, mo.obligation_id ASC;
+  `)).rows.map((row) => {
+		const receiverIfMakerIsSeller = (row.receiver_if_maker_is_seller ?? row.group_maker).toLowerCase();
 		return {
 			hash: row.hash,
-			obligationId: row.obligationId,
-			maker: row.maker,
+			obligationId: row.obligation_id,
+			maker: row.group_maker,
 			assets: BigInt(row.assets),
-			obligationUnits: BigInt(row.obligationUnits),
-			obligationShares: BigInt(row.obligationShares),
+			obligationUnits: BigInt(row.obligation_units ?? 0),
+			obligationShares: BigInt(row.obligation_shares ?? 0),
 			tick: row.tick,
-			maturity: from$16(row.maturity),
+			maturity: row.maturity,
 			expiry: row.expiry,
 			start: row.start,
 			group: row.group,
 			session: row.session,
 			buy: row.buy,
-			chainId: row.chainId,
-			loanToken: row.loanToken,
+			chainId: row.chain_id,
+			loanToken: row.loan_token,
 			collaterals: row.collaterals.map((c) => ({
 				asset: c.asset,
 				oracle: c.oracle,
 				lltv: BigInt(c.lltv)
 			})).sort((a, b) => a.asset.toLowerCase().localeCompare(b.asset.toLowerCase())),
 			callback: {
-				address: row.callbackAddress,
-				data: row.callbackData
+				address: row.callback_address,
+				data: row.callback_data
 			},
 			receiverIfMakerIsSeller,
-			consumed: BigInt(row.consumed),
+			consumed: BigInt(row.consumed ?? 0),
 			available: BigInt(String(row.available ?? "0").split(".")[0] ?? "0"),
 			takeable: BigInt(String(row.takeable ?? "0").split(".")[0] ?? "0"),
-			blockNumber: row.blockNumber
+			blockNumber: row.block_number
 		};
 	});
 	return {
 		rows,
-		nextCursor: rows.length === limit ? maker === void 0 ? rows[rows.length - 1].hash : formatOfferCursor(rows[rows.length - 1]) : null
+		nextCursor: rows.length === limit ? formatOfferCursor(rows[rows.length - 1]) : null
 	};
 }
+/**
+* Get offers with optional maker or obligation+side filter.
+* @param queryParameters - Raw query parameters from the API request.
+* @param db - The database client. {@link Database.Database}
+* @returns The offers response payload.
+*/
 async function getOffers$1(queryParameters, db) {
 	const logger = getLogger();
 	const result = safeParse("get_offers", queryParameters, (issue) => issue.message);
@@ -9187,9 +10295,12 @@ async function getOffers$1(queryParameters, db) {
 	} catch (err) {
 		logger.error({
 			err,
-			msg: "Error get offers",
-			errorMessage: err instanceof Error ? err.message : String(err),
-			errorStack: err instanceof Error ? err.stack : void 0
+			event: API_GET_OFFERS_FAILED,
+			msg: "Failed to get offers",
+			endpoint: "get_offers",
+			maker: query.maker ?? null,
+			obligation_id: query.obligation_id ?? null,
+			side: query.side ?? null
 		});
 		return failure(err);
 	}
@@ -9197,7 +10308,7 @@ async function getOffers$1(queryParameters, db) {
 function parseMakerCursor(cursor) {
 	const [rawHash, rawObligationId, ...tail] = cursor.split(":");
 	if (tail.length > 0) throw new Error("Invalid cursor format");
-	if (!rawHash || !rawObligationId || !HEX_32$1.test(rawHash) || !HEX_32$1.test(rawObligationId)) throw new Error("Invalid cursor format");
+	if (!rawHash || !rawObligationId || !HEX_32$1.test(rawHash) || !HEX_20$1.test(rawObligationId)) throw new Error("Invalid cursor format");
 	return {
 		hash: rawHash.toLowerCase(),
 		obligationId: rawObligationId.toLowerCase()
@@ -9207,6 +10318,7 @@ function formatOfferCursor(row) {
 	return `${row.hash.toLowerCase()}:${row.obligationId.toLowerCase()}`;
 }
 const HEX_32$1 = /^0x[a-fA-F0-9]{64}$/;
+const HEX_20$1 = /^0x[a-fA-F0-9]{40}$/;
 
 //#endregion
 //#region src/api/Controllers/getUserPositions.ts
@@ -9234,9 +10346,12 @@ async function getUserPositions(queryParameters, db) {
 	} catch (err) {
 		logger.error({
 			err,
-			msg: "Error get user positions",
-			errorMessage: err instanceof Error ? err.message : String(err),
-			errorStack: err instanceof Error ? err.stack : void 0
+			event: API_GET_USER_POSITIONS_FAILED,
+			msg: "Failed to get user positions",
+			endpoint: "get_user_positions",
+			user_address: query.user_address,
+			has_cursor: query.cursor != null,
+			limit: query.limit ?? null
 		});
 		return failure(err);
 	}
@@ -9297,11 +10412,18 @@ async function validateOffers(body, gatekeeper) {
 			cursor: null
 		});
 	} catch (err) {
+		const span = trace.getActiveSpan();
+		if (span) {
+			span.recordException(err);
+			span.setStatus({ code: SpanStatusCode.ERROR });
+		}
 		logger.error({
 			err,
-			msg: "Error validating offers",
-			errorMessage: err instanceof Error ? err.message : String(err),
-			errorStack: err instanceof Error ? err.stack : void 0
+			event: API_VALIDATE_OFFERS_FAILED,
+			msg: "Failed to validate offers",
+			endpoint: "validate_offers",
+			chain_id: chainId,
+			offers_count: parsedOffers.length
 		});
 		return failure(err);
 	}
@@ -9319,6 +10441,7 @@ var Controllers_exports = /* @__PURE__ */ __exportAll({
 	getHealthChains: () => getHealthChains,
 	getHealthCollectors: () => getHealthCollectors,
 	getIntegratorDocsHtml: () => getIntegratorDocsHtml,
+	getMetrics: () => getMetrics,
 	getObligation: () => getObligation,
 	getObligations: () => getObligations$1,
 	getOffers: () => getOffers$1,
@@ -9343,31 +10466,28 @@ function create$13(params) {
 	return { serve: () => serve$1(params) };
 }
 /**
-* Start a local router server.
-* @example
-* ```ts
-* import { RouterApi } from "@morpho-dev/router";
-* RouterApi.serve({ port: 8081 }); // local router API server running on http://localhost:8081
-* ```
+* Create the router API Hono app with all routes and middleware configured.
+* @param parameters - API construction parameters.
+* @returns Configured Hono app instance.
 */
-function serve$1(parameters) {
+function createApp(parameters) {
 	const { db, gatekeeper, chainRegistry } = parameters;
-	const tracer = getTracer("router.api");
 	const app = new Hono();
-	app.use("*", cors());
-	app.use("*", async (c, next) => {
-		const { req: { path, method } } = c;
-		const spanName = `${method} ${path}`;
-		return startActiveSpan(tracer, spanName, async (span) => {
-			const res = await next();
-			span.setAttribute("http.method", method);
-			span.setAttribute("http.target", path);
-			span.setAttribute("http.route", path);
-			span.setAttribute("http.status_code", c.res.status);
-			if (c.res.status >= 500) span.setStatus({ code: SpanStatusCode.ERROR });
-			return res;
-		});
+	init(app, {
+		component: "api",
+		tracerName: "router.api",
+		toFailurePayload: failure,
+		adaptFailurePayload: ({ route, failure }) => route === "/metrics" ? {
+			statusCode: failure.statusCode,
+			body: "# Failed to render router metrics\n",
+			contentType: "text/plain; version=0.0.4; charset=utf-8",
+			headers: { "Cache-Control": "no-store" }
+		} : void 0
 	});
+	app.use("*", cors({
+		origin: "*",
+		exposeHeaders: ["x-request-id"]
+	}));
 	app.get("/v1/offers", async (c) => {
 		const { statusCode, body } = await getOffers$1(c.req.query(), db);
 		return c.json(body, statusCode);
@@ -9392,14 +10512,9 @@ function serve$1(parameters) {
 		return c.json(body, statusCode);
 	});
 	app.post("/v1/validate", async (c) => {
-		try {
-			const reqBody = await c.req.json();
-			const { statusCode, body } = await gatekeeper.validate(reqBody);
-			return c.json(body, statusCode);
-		} catch (err) {
-			const failure$2 = failure(err);
-			return c.json(failure$2.body, failure$2.statusCode);
-		}
+		const reqBody = await c.req.json();
+		const { statusCode, body } = await gatekeeper.validate(reqBody);
+		return c.json(body, statusCode);
 	});
 	app.get("/v1/users/:userAddress/positions", async (c) => {
 		const query = c.req.query();
@@ -9422,24 +10537,37 @@ function serve$1(parameters) {
 		const { statusCode, body } = await getHealthChains(c.req.query(), db, void 0, chainRegistry);
 		return c.json(body, statusCode);
 	});
+	app.get("/metrics", async (c) => {
+		const body = await getMetrics(db, chainRegistry);
+		return c.text(body, 200, {
+			"Content-Type": "text/plain; version=0.0.4; charset=utf-8",
+			"Cache-Control": "no-store"
+		});
+	});
 	app.get("/v1/config/contracts", async (c) => {
 		const { statusCode, body } = await getConfigContracts(c.req.query(), chainRegistry);
 		return c.json(body, statusCode);
 	});
 	app.get("/v1/config/rules", async (c) => {
-		try {
-			const { statusCode, body } = await gatekeeper.getConfigRules(c.req.query());
-			return c.json(body, statusCode);
-		} catch (err) {
-			const failure$1 = failure(err);
-			return c.json(failure$1.body, failure$1.statusCode);
-		}
+		const { statusCode, body } = await gatekeeper.getConfigRules(c.req.query());
+		return c.json(body, statusCode);
 	});
 	app.get("/docs/openapi", async (c) => c.text(JSON.stringify(await getSwaggerJson()), 200, { "Content-Type": "application/json; charset=utf-8" }));
 	app.get("/docs/api", async (c) => c.html(await getDocsHtml(), 200));
 	app.get("/docs", async (c) => c.html(await getIntegratorDocsHtml(), 200));
+	return app;
+}
+/**
+* Start a local router server.
+* @example
+* ```ts
+* import { RouterApi } from "@morpho-dev/router";
+* RouterApi.serve({ port: 8081 }); // local router API server running on http://localhost:8081
+* ```
+*/
+function serve$1(parameters) {
 	serve({
-		fetch: app.fetch,
+		fetch: createApp(parameters).fetch,
 		port: parameters.port
 	});
 }
@@ -9467,6 +10595,7 @@ var RouterApi_exports = /* @__PURE__ */ __exportAll({
 	UsersController: () => UsersController,
 	ValidateController: () => ValidateController,
 	create: () => create$13,
+	createApp: () => createApp,
 	from: () => from$1,
 	parse: () => parse,
 	safeParse: () => safeParse
@@ -9655,6 +10784,7 @@ var HttpGetApiFailedError = class extends BaseError {
 //#endregion
 //#region src/database/drizzle/index.ts
 var drizzle_exports = /* @__PURE__ */ __exportAll({
+	CallbackTypes: () => CallbackTypes,
 	PositionTypes: () => PositionTypes,
 	StatusCode: () => StatusCode,
 	TABLE_NAMES: () => TABLE_NAMES,
@@ -10002,13 +11132,19 @@ async function _getOffers(db, params) {
         ON oia.obligation_id = w.obligation_id
       JOIN ${obligations} obl
         ON obl.obligation_key = oia.obligation_key
-    ),
-    paged AS (
-      SELECT e.*
+    )
+    ${offerTakeabilityCTEs({
+		sourceTable: "enriched",
+		groupScope: "winners",
+		now
+	})}
+    , paged AS (
+      SELECT e.*, COALESCE(ot.available, 0) AS available, ot.takeable
       FROM enriched e
+      JOIN offer_takeable ot ON ot.hash = e.hash AND ot.obligation_id = e.obligation_id
+      WHERE ot.takeable > 0
       ${cursor != null ? sql`
-        WHERE
-        (e.tick_norm, e.block_norm, e.assets_norm, e.hash_norm)
+        AND (e.tick_norm, e.block_norm, e.assets_norm, e.hash_norm)
           > (
               CASE WHEN ${priceSortDirection === "asc" ? sql`TRUE` : sql`FALSE`}
                 THEN ${cursor.tick}::integer ELSE -${cursor.tick}::integer END,
@@ -10018,224 +11154,38 @@ async function _getOffers(db, params) {
             )` : sql``}
       ORDER BY e.tick ${priceSortDirection === "asc" ? sql`ASC` : sql`DESC`}, e.block_number ASC, e.assets DESC, e.hash ASC
       LIMIT ${limit}
-    ),
-    -- Compute sum of offsets per position and obligation
-    position_offsets AS (
-      SELECT
-        chain_id,
-        "user",
-        contract,
-        obligation_id,
-        SUM(value::numeric) AS total_offset
-      FROM ${offsets}
-      GROUP BY chain_id, "user", contract, obligation_id
-    ),
-    -- Compute position_consumed: sum of consumed from all groups with lots on each position+obligation (converted to lot terms)
-    position_consumed AS (
-      SELECT
-        l.chain_id,
-        l.contract,
-        l."user",
-        l.obligation_id,
-        SUM(
-          CASE
-            WHEN wo.assets::numeric > 0
-            THEN COALESCE(g.consumed::numeric, 0) * (l.upper::numeric - l.lower::numeric) / wo.assets::numeric
-            ELSE 0
-          END
-        ) AS consumed
-      FROM ${lots} l
-      JOIN ${groups} g
-        ON g.chain_id = l.chain_id
-        AND LOWER(g.maker) = LOWER(l."user")
-        AND g."group" = l."group"
-      JOIN winners wo
-        ON wo.group_chain_id = g.chain_id
-        AND LOWER(wo.group_maker) = LOWER(g.maker)
-        AND wo.group_group = g."group"
-      GROUP BY l.chain_id, l.contract, l."user", l.obligation_id
-    ),
-    -- Compute callback contributions with lot balance
-    callback_contributions AS (
-      SELECT
-        p.hash,
-        p.obligation_id,
-        p.assets,
-        p.tick,
-        p.obligation_units,
-        p.obligation_shares,
-        p.maturity,
-        p.expiry,
-        p.start,
-        p.group_group,
-        p.buy,
-        p.callback_address,
-        p.callback_data,
-        p.receiver_if_maker_is_seller,
-        p.block_number,
-        p.group_chain_id,
-        p.group_maker,
-        p.consumed,
-        p.chain_id,
-        p.loan_token,
-        p.session,
-        c.id AS callback_id,
-        c.position_chain_id,
-        c.position_contract,
-        c.position_user,
-        c.amount AS callback_amount,
-        pos.balance AS position_balance,
-        pos.asset AS position_asset,
-        l.lower AS lot_lower,
-        l.upper AS lot_upper,
-        -- Compute lot_balance: min(position_balance + offset + position_consumed - lot.lower, lot.size - lot_consumed)
-        -- lot_consumed is converted from loan token to lot terms: consumed * lot_size / assets
-        GREATEST(0, LEAST(
-          COALESCE(pos.balance::numeric, 0) + COALESCE(pos_offsets.total_offset, 0) + COALESCE(pc.consumed, 0) - COALESCE(l.lower::numeric, 0),
-          (COALESCE(l.upper::numeric, 0) - COALESCE(l.lower::numeric, 0)) -
-            CASE
-              WHEN p.assets::numeric > 0
-              THEN COALESCE(p.consumed::numeric, 0) * (COALESCE(l.upper::numeric, 0) - COALESCE(l.lower::numeric, 0)) / p.assets::numeric
-              ELSE 0
-            END
-        )) AS lot_balance
-      FROM paged p
-      LEFT JOIN ${offersCallbacks} oc
-        ON oc.offer_hash = p.hash
-        AND oc.obligation_id = p.obligation_id
-      LEFT JOIN ${callbacks} c ON c.id = oc.callback_id
-      LEFT JOIN ${lots} l
-        ON l.chain_id = c.position_chain_id
-        AND LOWER(l.contract) = LOWER(c.position_contract)
-        AND LOWER(l."user") = LOWER(c.position_user)
-        AND l."group" = p.group_group
-        AND l.obligation_id = p.obligation_id
-      LEFT JOIN ${positions} pos
-        ON pos.chain_id = c.position_chain_id
-        AND LOWER(pos.contract) = LOWER(c.position_contract)
-        AND LOWER(pos."user") = LOWER(c.position_user)
-      LEFT JOIN position_offsets pos_offsets
-        ON pos_offsets.chain_id = c.position_chain_id
-        AND LOWER(pos_offsets.contract) = LOWER(c.position_contract)
-        AND LOWER(pos_offsets."user") = LOWER(c.position_user)
-        AND pos_offsets.obligation_id = p.obligation_id
-      LEFT JOIN position_consumed pc
-        ON pc.chain_id = c.position_chain_id
-        AND LOWER(pc.contract) = LOWER(c.position_contract)
-        AND LOWER(pc."user") = LOWER(c.position_user)
-        AND pc.obligation_id = p.obligation_id
-    ),
-    -- Compute contribution per callback in loan terms (loan token only — collateral positions are not indexed)
-    callback_loan_contribution AS (
-      SELECT
-        cc.*,
-        CASE
-          WHEN cc.lot_lower IS NULL THEN 0
-          ELSE LEAST(cc.lot_balance, COALESCE(cc.callback_amount::numeric, cc.lot_balance))
-        END AS contribution_in_loan
-      FROM callback_contributions cc
-    ),
-    -- Aggregate contributions per offer, deduplicating by position using DISTINCT ON
-    offer_contributions AS (
-      SELECT
-        hash,
-        obligation_id,
-        assets,
-        tick,
-        obligation_units,
-        obligation_shares,
-        maturity,
-        expiry,
-        start,
-        group_group,
-        buy,
-        callback_address,
-        callback_data,
-        receiver_if_maker_is_seller,
-        block_number,
-        group_chain_id,
-        group_maker,
-        consumed,
-        chain_id,
-        loan_token,
-        session,
-        SUM(contribution_in_loan) AS total_available
-      FROM (
-        -- Take max contribution per position using DISTINCT ON (idiomatic PostgreSQL)
-        SELECT DISTINCT ON (clc.hash, clc.position_chain_id, clc.position_contract, clc.position_user)
-          clc.*
-        FROM callback_loan_contribution clc
-        WHERE clc.callback_id IS NOT NULL
-        ORDER BY clc.hash, clc.position_chain_id, clc.position_contract, clc.position_user, clc.contribution_in_loan DESC
-      ) deduped
-      GROUP BY hash, obligation_id, assets, tick, 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, receiver_if_maker_is_seller
-      UNION ALL
-      -- Sell offers without callbacks: collateral positions not indexed, takeable = assets - consumed
-      SELECT
-        p.hash, p.obligation_id, p.assets, p.tick,
-        p.obligation_units, p.obligation_shares,
-        p.maturity, p.expiry, p.start, p.group_group,
-        p.buy, p.callback_address, p.callback_data,
-        p.receiver_if_maker_is_seller,
-        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
-            AND oc2.obligation_id = p.obligation_id
-        )
     )
-    -- Final SELECT with inline takeable computation
     SELECT
-      oc.hash,
-      oc.obligation_id,
-      oc.group_maker,
-      oc.assets,
-      oc.obligation_units,
-      oc.obligation_shares,
-      oc.consumed,
-      oc.tick,
-      oc.maturity,
-      oc.expiry,
-      oc.start,
-      oc.group_group AS "group",
-      oc.buy,
-      oc.chain_id,
-      oc.loan_token,
-      oc.callback_address,
-      oc.callback_data,
-      oc.receiver_if_maker_is_seller,
-      oc.block_number,
-      oc.session,
-      COALESCE(oc.total_available, 0) AS available,
-      -- 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,
+      p.hash,
+      p.obligation_id,
+      p.group_maker,
+      p.assets,
+      p.obligation_units,
+      p.obligation_shares,
+      p.consumed,
+      p.tick,
+      p.maturity,
+      p.expiry,
+      p.start,
+      p.group_group AS "group",
+      p.buy,
+      p.chain_id,
+      p.loan_token,
+      p.callback_address,
+      p.callback_data,
+      p.receiver_if_maker_is_seller,
+      p.block_number,
+      p.session,
+      p.available,
+      p.takeable,
       c.collaterals
-    FROM offer_contributions oc
-    LEFT JOIN collats c ON c.obligation_id = oc.obligation_id
-    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
+    FROM paged p
+    LEFT JOIN collats c ON c.obligation_id = p.obligation_id
     ORDER BY
-      oc.tick ${priceSortDirection === "asc" ? sql`ASC` : sql`DESC`},
-      oc.block_number ASC,
-      oc.assets DESC,
-      oc.hash ASC;
+      p.tick ${priceSortDirection === "asc" ? sql`ASC` : sql`DESC`},
+      p.block_number ASC,
+      p.assets DESC,
+      p.hash ASC;
   `);
 	return {
 		rows: raw.rows.map((row) => {
@@ -10351,7 +11301,7 @@ function create$10(db) {
 			const callbacksRows = [];
 			const offersCallbacksRows = [];
 			const callbackId = (input) => {
-				const preimage = `0x${input.chainId}${input.contract}${input.user}${input.amount.toString()}`.toLowerCase();
+				const preimage = `0x${input.chainId}${input.contract}${input.user}`.toLowerCase();
 				const id = idCache.get(preimage) ?? keccak256(preimage);
 				idCache.set(preimage, id);
 				return id;
@@ -10364,8 +11314,8 @@ function create$10(db) {
 						chainId: callback.chainId,
 						contract: callback.contract.toLowerCase(),
 						user: callback.user.toLowerCase(),
-						amount: callback.amount,
-						positionTypeId: callback.positionTypeId
+						positionTypeId: callback.positionTypeId,
+						type: callback.type
 					};
 					const id = callbackId(normalized);
 					offersCallbacksRows.push({
@@ -10381,7 +11331,7 @@ function create$10(db) {
 						positionContract: normalized.contract,
 						positionUser: normalized.user,
 						positionTypeId: normalized.positionTypeId,
-						amount: normalized.amount.toString()
+						type: normalized.type
 					});
 				}
 			}
@@ -10405,10 +11355,10 @@ function create$9(db) {
 	return {
 		create: async (events) => {
 			if (events.length === 0) return;
-			const groups$2 = /* @__PURE__ */ new Map();
+			const groups$3 = /* @__PURE__ */ new Map();
 			for (const event of events) {
 				const groupId = `${event.chainId}-${event.maker}-${event.group}`.toLowerCase();
-				groups$2.set(groupId, {
+				groups$3.set(groupId, {
 					chainId: event.chainId,
 					maker: event.maker,
 					group: event.group,
@@ -10416,7 +11366,7 @@ function create$9(db) {
 				});
 			}
 			await db.transaction(async (dbTx) => {
-				const groupsRows = Array.from(groups$2.values()).map((group) => ({
+				const groupsRows = Array.from(groups$3.values()).map((group) => ({
 					chainId: group.chainId,
 					maker: group.maker.toLowerCase(),
 					group: group.group.toLowerCase(),
@@ -10444,23 +11394,42 @@ function create$9(db) {
 
 //#endregion
 //#region src/database/domains/Groups.ts
+/** Build composite key for a group. */
+function compositeKey(g) {
+	return `${g.chainId}-${g.maker.toLowerCase()}-${g.group.toLowerCase()}`;
+}
 /**
 * Create a groups domain instance.
 * @param db - Database core instance.
 * @returns Groups domain. {@link GroupsDomain}
 */
 function create$8(db) {
-	return { create: async (groups$1) => {
-		if (groups$1.length === 0) return;
-		const rows = groups$1.map((group) => ({
-			chainId: group.chainId,
-			maker: group.maker.toLowerCase(),
-			group: group.group.toLowerCase(),
-			consumed: (group.consumed ?? 0n).toString(),
-			blockNumber: group.blockNumber
-		}));
-		for (const batch of batch$1(rows, DEFAULT_BATCH_SIZE$1)) await db.insert(groups).values(batch).onConflictDoNothing();
-	} };
+	return {
+		create: async (groups$1) => {
+			if (groups$1.length === 0) return;
+			const rows = groups$1.map((group) => ({
+				chainId: group.chainId,
+				maker: group.maker.toLowerCase(),
+				group: group.group.toLowerCase(),
+				consumed: (group.consumed ?? 0n).toString(),
+				blockNumber: group.blockNumber
+			}));
+			for (const batch of batch$1(rows, DEFAULT_BATCH_SIZE$1)) await db.insert(groups).values(batch).onConflictDoNothing();
+		},
+		exists: async (groups$2) => {
+			if (groups$2.length === 0) return [];
+			const tuples = groups$2.map((g) => sql`(${sql.raw(g.chainId.toString())}::bigint, ${g.maker.toLowerCase()}, ${g.group.toLowerCase()})`);
+			return (await db.select({
+				chainId: groups.chainId,
+				maker: groups.maker,
+				group: groups.group
+			}).from(groups).where(sql`(${groups.chainId}, ${groups.maker}, ${groups.group}) IN (${sql.join(tuples, sql`, `)})`)).map((row) => ({
+				chainId: row.chainId,
+				maker: row.maker,
+				group: row.group
+			}));
+		}
+	};
 }
 
 //#endregion
@@ -10812,13 +11781,15 @@ const create$3 = (db) => {
               group_chain_id,
               group_maker,
               "group_group",
+              obligation_id,
               MAX(assets::numeric) AS assets
             FROM ${offers}
-            GROUP BY group_chain_id, group_maker, "group_group"
+            GROUP BY group_chain_id, group_maker, "group_group", obligation_id
           ) offer_agg
             ON offer_agg.group_chain_id = g.chain_id
             AND LOWER(offer_agg.group_maker) = LOWER(g.maker)
             AND offer_agg."group_group" = g."group"
+            AND offer_agg.obligation_id = l.obligation_id
           WHERE LOWER(l."user") = LOWER(${user})
           GROUP BY l.chain_id, l.contract, l."user", l.obligation_id
         ),
@@ -11189,9 +12160,10 @@ function create$1(db) {
 	};
 }
 const HEX_32 = /^0x[a-fA-F0-9]{64}$/;
+const HEX_20 = /^0x[a-fA-F0-9]{40}$/;
 function parseCursor(cursor) {
 	const [offerHash, obligationId] = cursor.split(":");
-	if (!offerHash || !obligationId || !HEX_32.test(offerHash) || !HEX_32.test(obligationId)) throw new Error("Invalid cursor format");
+	if (!offerHash || !obligationId || !HEX_32.test(offerHash) || !HEX_20.test(obligationId)) throw new Error("Invalid cursor format");
 	return {
 		offerHash: offerHash.toLowerCase(),
 		obligationId: obligationId.toLowerCase()
@@ -11527,6 +12499,9 @@ async function postMigrate(driver) {
       WHERE o.group_chain_id = t.group_chain_id
         AND o.group_maker    = t.group_maker
         AND o.group_group    = t."group"
+        AND g.chain_id       = t.group_chain_id
+        AND g.maker          = t.group_maker
+        AND g."group"        = t."group"
         AND o.assets        <= g.consumed;
       RETURN NULL;
     END;
@@ -11603,62 +12578,10 @@ async function postMigrate(driver) {
     EXECUTE FUNCTION cleanup_orphan_groups();
     `);
 		await driver.execute(`
-    CREATE OR REPLACE FUNCTION cleanup_orphan_obligations_and_oracles()
-    RETURNS TRIGGER AS $$
-    DECLARE
-      orphan_obligation_ids TEXT[];
-      orphan_obligation_keys TEXT[];
-    BEGIN
-      -- 1. Find orphan obligation IDs
-      SELECT ARRAY_AGG(DISTINCT obligation_id) INTO orphan_obligation_ids
-      FROM deleted_rows d
-      WHERE NOT EXISTS (
-        SELECT 1 FROM "${VERSION}"."offers" ov
-        WHERE ov.obligation_id = d.obligation_id
-      )
-      AND NOT EXISTS (
-        SELECT 1 FROM "${VERSION}"."positions" p
-        JOIN "${VERSION}"."position_types" pt ON pt.id = p.position_type_id
-        WHERE p."contract" = d.obligation_id
-          AND pt.type IN ('debtOf', 'collateralOf')
-      );
-
-      -- 2. If no orphan obligation IDs, exit early
-      IF orphan_obligation_ids IS NULL OR array_length(orphan_obligation_ids, 1) IS NULL THEN
-        RETURN NULL;
-      END IF;
-
-      -- 3. Delete orphan obligation id keys
-      DELETE FROM "${VERSION}"."obligation_id_keys" oia
-      WHERE oia.obligation_id = ANY(orphan_obligation_ids);
-
-      -- 4. Find canonical obligation keys with no remaining obligation id keys
-      SELECT ARRAY_AGG(ob.obligation_key) INTO orphan_obligation_keys
-      FROM "${VERSION}"."obligations" ob
-      WHERE NOT EXISTS (
-        SELECT 1 FROM "${VERSION}"."obligation_id_keys" oia
-        WHERE oia.obligation_key = ob.obligation_key
-      );
-
-      -- 5. If no orphan canonical obligations, exit early
-      IF orphan_obligation_keys IS NULL OR array_length(orphan_obligation_keys, 1) IS NULL THEN
-        RETURN NULL;
-      END IF;
-
-      -- 6. Delete orphan canonical obligations (cascades to collaterals)
-      DELETE FROM "${VERSION}"."obligations" ob
-      WHERE ob.obligation_key = ANY(orphan_obligation_keys);
-
-      RETURN NULL;
-    END;
-    $$ LANGUAGE plpgsql;
+    DROP TRIGGER IF EXISTS trg_cleanup_orphan_obligations_and_oracles ON "${VERSION}"."offers";
     `);
 		await driver.execute(`
-    CREATE OR REPLACE TRIGGER trg_cleanup_orphan_obligations_and_oracles
-    AFTER DELETE ON "${VERSION}"."offers"
-    REFERENCING OLD TABLE AS deleted_rows
-    FOR EACH STATEMENT
-    EXECUTE FUNCTION cleanup_orphan_obligations_and_oracles();
+    DROP FUNCTION IF EXISTS cleanup_orphan_obligations_and_oracles();
     `);
 		await driver.execute(`
     CREATE OR REPLACE FUNCTION create_offset_on_lot_delete()
@@ -11736,6 +12659,21 @@ async function postMigrate(driver) {
 	});
 }
 
+//#endregion
+//#region src/observability/TraceHeaders.ts
+/**
+* Inject active trace context headers into outgoing HTTP headers.
+* @param headers - Existing headers for the outgoing request.
+* @returns Headers enriched with active trace context.
+*/
+function withActiveTraceHeaders(headers) {
+	const enrichedHeaders = new Headers(headers);
+	const carrier = {};
+	propagation.inject(context.active(), carrier);
+	for (const [key, value] of Object.entries(carrier)) enrichedHeaders.set(key, value);
+	return enrichedHeaders;
+}
+
 //#endregion
 //#region src/gatekeeper/Client.ts
 var Client_exports = /* @__PURE__ */ __exportAll({ createHttpClient: () => createHttpClient });
@@ -11756,7 +12694,7 @@ function createHttpClient(config) {
 		try {
 			return await fetchFn(`${baseUrl}${path}`, {
 				...init,
-				headers: mergeHeaders(baseHeaders, init.headers),
+				headers: withActiveTraceHeaders(mergeHeaders(baseHeaders, init.headers)),
 				signal: controller.signal
 			});
 		} finally {
@@ -11953,8 +12891,12 @@ var Rules_exports = /* @__PURE__ */ __exportAll({
 	amountMutualExclusivity: () => amountMutualExclusivity,
 	callback: () => callback,
 	collateralToken: () => collateralToken,
+	groupConsistency: () => groupConsistency,
+	groupImmutability: () => groupImmutability,
 	loanToken: () => loanToken,
 	maturity: () => maturity,
+	maxCollaterals: () => maxCollaterals,
+	minDuration: () => minDuration,
 	oracle: () => oracle,
 	sameMaker: () => sameMaker
 });
@@ -12021,14 +12963,98 @@ const sameMaker = () => batch("mixed_maker", "Validates that all offers in a bat
 * At most one of (assets, obligationUnits, obligationShares) can be non-zero.
 * Matches contract requirement: `atMostOneNonZero(offer.assets, offer.obligationUnits, offer.obligationShares)`.
 */
+/**
+* A validation rule that checks if the offer duration (expiry - start) meets a minimum threshold.
+* @param minSeconds - Minimum required duration in seconds.
+* @returns The issue that was found. If the offer is valid, this will be undefined.
+*/
+const minDuration = ({ minSeconds }) => single("min_duration", `Validates that offer duration (expiry - start) is at least ${minSeconds}s`, (offer) => {
+	const duration = offer.expiry - offer.start;
+	if (duration < minSeconds) return { message: `Duration ${duration}s is below minimum ${minSeconds}s` };
+});
+/**
+* A validation rule that checks if an offer exceeds the maximum number of collaterals.
+* The contract enforces this limit; this rule rejects early to avoid on-chain reverts.
+* @param max - Maximum allowed collaterals per offer.
+* @returns The issue that was found. If the offer is valid, this will be undefined.
+*/
+const maxCollaterals = ({ max }) => single("max_collaterals", `Validates that an offer has at most ${max} collaterals`, (offer) => {
+	if (offer.collaterals.length > max) return { message: `Offer has ${offer.collaterals.length} collaterals, exceeding the maximum of ${max}` };
+});
 const amountMutualExclusivity = () => single("amount_mutual_exclusivity", "Validates that at most one of (assets, obligationUnits, obligationShares) is non-zero", (offer) => {
 	if (!atMostOneNonZero(offer.assets, offer.obligationUnits, offer.obligationShares)) return { message: "Inconsistent offer input: at most one of (assets, obligationUnits, obligationShares) must be non-zero" };
 });
+/**
+* A batch validation rule that ensures all offers within the same group are consistent.
+* All offers sharing the same group must have the same loan token, assets amount, and side (buy/sell).
+*/
+const groupConsistency = () => batch("group_consistency", "Validates that all offers in a group have the same loan token, assets amount, and side", (offers) => {
+	const issues = /* @__PURE__ */ new Map();
+	if (offers.length === 0) return issues;
+	const groupMap = /* @__PURE__ */ new Map();
+	for (let i = 0; i < offers.length; i++) {
+		const key = offers[i].group.toLowerCase();
+		const indices = groupMap.get(key);
+		if (indices) indices.push(i);
+		else groupMap.set(key, [i]);
+	}
+	for (const indices of groupMap.values()) {
+		if (indices.length <= 1) continue;
+		const reference = offers[indices[0]];
+		const refLoanToken = reference.loanToken.toLowerCase();
+		const refAssets = reference.assets;
+		const refBuy = reference.buy;
+		for (let j = 1; j < indices.length; j++) {
+			const idx = indices[j];
+			const offer = offers[idx];
+			if (offer.loanToken.toLowerCase() !== refLoanToken) issues.set(idx, { message: `All offers in a group must have the same loan token. Expected ${reference.loanToken}, got ${offer.loanToken}` });
+			else if (offer.assets !== refAssets) issues.set(idx, { message: `All offers in a group must have the same assets amount. Expected ${refAssets}, got ${offer.assets}` });
+			else if (offer.buy !== refBuy) issues.set(idx, { message: `All offers in a group must be on the same side. Expected ${refBuy ? "buy" : "sell"}, got ${offer.buy ? "buy" : "sell"}` });
+		}
+	}
+	return issues;
+});
+/**
+* A batch validation rule that prevents adding offers to groups that already exist in the database.
+* Groups are immutable after creation — new offers cannot be added to an existing group.
+*/
+const groupImmutability = ({ db, chainId }) => batch("group_immutability", "Validates that offers do not target groups that already exist", async (offers) => {
+	const issues = /* @__PURE__ */ new Map();
+	if (offers.length === 0) return issues;
+	const uniqueGroups = /* @__PURE__ */ new Map();
+	for (const offer of offers) {
+		const key = compositeKey({
+			chainId,
+			maker: offer.maker,
+			group: offer.group
+		});
+		if (!uniqueGroups.has(key)) uniqueGroups.set(key, {
+			chainId,
+			maker: offer.maker,
+			group: offer.group
+		});
+	}
+	const existingKeys = await db.groups.exists(Array.from(uniqueGroups.values()));
+	if (existingKeys.length === 0) return issues;
+	const existingSet = new Set(existingKeys.map((k) => compositeKey(k)));
+	for (let i = 0; i < offers.length; i++) {
+		const offer = offers[i];
+		const key = compositeKey({
+			chainId,
+			maker: offer.maker,
+			group: offer.group
+		});
+		if (existingSet.has(key)) issues.set(i, { message: `Cannot add offers to existing group ${offer.group}` });
+	}
+	return issues;
+});
 
 //#endregion
 //#region src/gatekeeper/morphoRules.ts
 const morphoRules = (parameters) => {
-	const { chains, chainId } = parameters;
+	const { chains, chainId, db } = parameters;
+	const requestChain = chains.find((c) => c.id === chainId);
+	const config = requestChain ? configs[requestChain.name] : void 0;
 	const assetsByChainId = {};
 	const collateralAssetsByChainId = {};
 	const oraclesByChainId = {};
@@ -12037,9 +13063,11 @@ const morphoRules = (parameters) => {
 		collateralAssetsByChainId[chain.id] = collateralAssets[chain.id.toString()] ?? [];
 		oraclesByChainId[chain.id] = oracles[chain.id.toString()] ?? [];
 	}
-	return [
+	const rules = [
 		sameMaker(),
 		amountMutualExclusivity(),
+		groupConsistency(),
+		...config?.minDuration != null ? [minDuration({ minSeconds: config.minDuration })] : [],
 		maturity({ maturities: [MaturityType.EndOfWeek, MaturityType.EndOfNextWeek] }),
 		callback({
 			callbacks: [Type$1.BuyWithEmptyCallback, Type$1.SellWithEmptyCallback],
@@ -12049,6 +13077,7 @@ const morphoRules = (parameters) => {
 			assetsByChainId,
 			chainId
 		}),
+		maxCollaterals({ max: 128 }),
 		collateralToken({
 			collateralAssetsByChainId,
 			chainId
@@ -12058,6 +13087,11 @@ const morphoRules = (parameters) => {
 			chainId
 		})
 	];
+	if (db) rules.push(groupImmutability({
+		db,
+		chainId
+	}));
+	return rules;
 };
 
 //#endregion