@morpho-dev/router 0.12.0 → 0.12.1

package/dist/cli.js

@@ -211,7 +211,7 @@ function startActiveSpan(tracer, name, fn) {
 //#endregion
 //#region package.json
 var name = "@morpho-dev/router";
-var version = "0.12.0";
+var version = "0.12.1";
 var description = "Router package for Morpho protocol";
 
 //#endregion
@@ -341,8 +341,8 @@ const chains$1 = {
 		name: "base",
 		custom: {
 			morpho: {
-				address: "0xee437005ba0a3d0e9bc6510775c41f23ed2909e1",
-				blockCreated: 43515847
+				address: "0x26378861d9c740fe86e7472752aef5b1a783c60b",
+				blockCreated: 43606117
 			},
 			morphoBlue: {
 				address: "0xBBBBBbbBBb9cC5e90e3b3Af64bdAF62C37EEFFCb",
@@ -371,8 +371,8 @@ const chains$1 = {
 		name: "ethereum-virtual-testnet",
 		custom: {
 			morpho: {
-				address: "0xc1c6e6fa308eeef18e96be420d8ccb218215a26c",
-				blockCreated: 23244321
+				address: "0x94c576ee728ee290116ee65c0d1e9fed4a1b5041",
+				blockCreated: 23244323
 			},
 			morphoBlue: {
 				address: "0xBBBBBbbBBb9cC5e90e3b3Af64bdAF62C37EEFFCb",
@@ -807,7 +807,7 @@ async function startDetached(config, logPath) {
 }
 async function startInProcess(config, logPath) {
 	fs.closeSync(fs.openSync(logPath, "w"));
-	const { startServer: startProolServer } = await import("./server-D4xxddev.js");
+	const { startServer: startProolServer } = await import("./server-DNFuP89-.js");
 	const stop = await startProolServer(config);
 	return {
 		process: {
@@ -929,6 +929,7 @@ const transformAddress = (val, ctx) => {
 	});
 	return z$2.NEVER;
 };
+const AddressSchema = z$2.string().transform(transformAddress);
 
 //#endregion
 //#region src/chain/state.ts
@@ -1767,14 +1768,8 @@ const isEmptyCallback = (offer) => offer.callback.data === "0x";
 
 //#endregion
 //#region src/core/Maturity.ts
-const MaturitySchema = z$2.number().int().refine((maturity) => {
-	try {
-		from$15(maturity);
-		return true;
-	} catch (_e) {
-		return false;
-	}
-}, { error: (issue) => {
+const MAX_TIMESTAMP_SECONDS = 999999999999;
+const MaturitySchema = z$2.number().int().max(MAX_TIMESTAMP_SECONDS).refine(isAt15UTC, { error: (issue) => {
 	try {
 		return `The maturity is set to ${/* @__PURE__ */ new Date(issue.input * 1e3)}. It must be at 15:00:00 UTC.`;
 	} catch (_) {
@@ -1809,7 +1804,7 @@ function from$15(ts) {
 		if (ts in MaturityOptions) return MaturityOptions[ts]();
 		throw new InvalidOptionError$1(ts);
 	}
-	if (typeof ts === "number" && ts > 0xe8d4a51000) throw new InvalidFormatError();
+	if (typeof ts === "number" && ts > MAX_TIMESTAMP_SECONDS) throw new InvalidFormatError();
 	if (!isAt15UTC(ts)) throw new InvalidDateError(ts);
 	return ts;
 }
@@ -1903,7 +1898,6 @@ const assets = {
 		"0x833589fCD6eDb6E08f4c7C32D4f71b54bdA02913",
 		"0x50c5725949A6F0c72E6C4a641F24049A917DB0Cb",
 		"0x4200000000000000000000000000000000000006",
-		"0x2260FAC5E5542a773Aa44fBCfeDf7C193bc2C599",
 		"0xcbB7C0000aB88B473b1f5aFd9ef808440eed33Bf",
 		"0xc1CBa3fCea344f92D9239c08C0568f6F2F0ee452",
 		"0x60a3E35Cc302bFA44Cb288Bc5a4F316Fdb1adb42"
@@ -2055,7 +2049,7 @@ const MorphoV2 = parseAbi([
 	"function obligationCreated(bytes32 id) view returns (bool)",
 	"function obligationState(bytes32 id) view returns (uint128 totalUnits, uint256 withdrawable, uint128 lossIndex, bool created)",
 	"function owner() view returns (address)",
-	"function repay((address loanToken, (address token, uint256 lltv, uint256 maxLif, address oracle)[] collaterals, uint256 maturity, uint256 rcfThreshold) obligation, uint256 obligationUnits, address onBehalf)",
+	"function repay((address loanToken, (address token, uint256 lltv, uint256 maxLif, address oracle)[] collaterals, uint256 maturity, uint256 rcfThreshold) obligation, uint256 units, address onBehalf)",
 	"function session(address user) view returns (bytes32)",
 	"function setConsumed(bytes32 group, uint256 amount, address onBehalf)",
 	"function setDefaultTradingFee(address loanToken, uint256 index, uint256 newTradingFee)",
@@ -2070,7 +2064,7 @@ const MorphoV2 = parseAbi([
 	"function shuffleSession(address onBehalf)",
 	"function slash(bytes32 id, address user)",
 	"function supplyCollateral((address loanToken, (address token, uint256 lltv, uint256 maxLif, address oracle)[] collaterals, uint256 maturity, uint256 rcfThreshold) obligation, uint256 collateralIndex, uint256 assets, address onBehalf)",
-	"function take(uint256 obligationUnits, address taker, address takerCallback, bytes takerCallbackData, address receiverIfTakerIsSeller, ((address loanToken, (address token, uint256 lltv, uint256 maxLif, address oracle)[] collaterals, uint256 maturity, uint256 rcfThreshold) obligation, bool buy, address maker, uint256 obligationUnits, uint256 start, uint256 expiry, uint256 tick, bytes32 group, bytes32 session, address callback, bytes callbackData, address receiverIfMakerIsSeller, bool exitOnly) offer, (uint8 v, bytes32 r, bytes32 s) sig, bytes32 root, bytes32[] proof) returns (uint256, uint256, uint256)",
+	"function take(uint256 units, address taker, address takerCallback, bytes takerCallbackData, address receiverIfTakerIsSeller, ((address loanToken, (address token, uint256 lltv, uint256 maxLif, address oracle)[] collaterals, uint256 maturity, uint256 rcfThreshold) obligation, bool buy, address maker, uint256 maxUnits, uint256 start, uint256 expiry, uint256 tick, bytes32 group, bytes32 session, address callback, bytes callbackData, address receiverIfMakerIsSeller, bool exitOnly) offer, (uint8 v, bytes32 r, bytes32 s) sig, bytes32 root, bytes32[] proof) returns (uint256, uint256, uint256)",
 	"function toId((address loanToken, (address token, uint256 lltv, uint256 maxLif, address oracle)[] collaterals, uint256 maturity, uint256 rcfThreshold) obligation) view returns (bytes32)",
 	"function toObligation(bytes32 id) view returns ((address loanToken, (address token, uint256 lltv, uint256 maxLif, address oracle)[] collaterals, uint256 maturity, uint256 rcfThreshold))",
 	"function totalUnits(bytes32 id) view returns (uint256)",
@@ -2078,14 +2072,14 @@ const MorphoV2 = parseAbi([
 	"function tradingFee(bytes32 id, uint256 timeToMaturity) view returns (uint256)",
 	"function tradingFeeRecipient() view returns (address)",
 	"function userLossIndex(bytes32 id, address user) view returns (uint128)",
-	"function withdraw((address loanToken, (address token, uint256 lltv, uint256 maxLif, address oracle)[] collaterals, uint256 maturity, uint256 rcfThreshold) obligation, uint256 obligationUnits, address onBehalf, address receiver)",
+	"function withdraw((address loanToken, (address token, uint256 lltv, uint256 maxLif, address oracle)[] collaterals, uint256 maturity, uint256 rcfThreshold) obligation, uint256 units, address onBehalf, address receiver)",
 	"function withdrawCollateral((address loanToken, (address token, uint256 lltv, uint256 maxLif, address oracle)[] collaterals, uint256 maturity, uint256 rcfThreshold) obligation, uint256 collateralIndex, uint256 assets, address onBehalf, address receiver)",
 	"function withdrawable(bytes32 id) view returns (uint256)",
 	"event Constructor(address indexed owner)",
 	"event FlashLoan(address indexed caller, address indexed token, uint256 assets)",
 	"event Liquidate(address indexed caller, bytes32 indexed id_, uint256 collateralIndex, uint256 seizedAssets, uint256 repaidUnits, address indexed borrower, uint256 badDebt, uint256 latestLossIndex)",
 	"event ObligationCreated(bytes32 indexed id_, (address loanToken, (address token, uint256 lltv, uint256 maxLif, address oracle)[] collaterals, uint256 maturity, uint256 rcfThreshold) obligation)",
-	"event Repay(address indexed caller, bytes32 indexed id_, uint256 obligationUnits, address indexed onBehalf)",
+	"event Repay(address indexed caller, bytes32 indexed id_, uint256 units, address indexed onBehalf)",
 	"event SetConsumed(address indexed caller, address indexed onBehalf, bytes32 indexed group, uint256 amount)",
 	"event SetDefaultTradingFee(address indexed loanToken, uint256 indexed index, uint256 newTradingFee)",
 	"event SetFeeSetter(address indexed feeSetter)",
@@ -2099,8 +2093,8 @@ const MorphoV2 = parseAbi([
 	"event ShuffleSession(address indexed caller, address indexed onBehalf, bytes32 session)",
 	"event Slash(address caller, bytes32 indexed id_, address indexed user, uint256 credit, uint256 latestLossIndex)",
 	"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, address sellerReceiver, bytes32 group, uint256 consumed, uint256 totalUnits)",
-	"event Withdraw(address caller, bytes32 indexed id_, uint256 obligationUnits, address indexed onBehalf, address indexed receiver)",
+	"event Take(address caller, bytes32 indexed id_, address indexed maker, address indexed taker, bool offerIsBuy, uint256 buyerAssets, uint256 sellerAssets, uint256 units, address sellerReceiver, bytes32 group, uint256 consumed, uint256 totalUnits)",
+	"event Withdraw(address caller, bytes32 indexed id_, uint256 units, address indexed onBehalf, address indexed receiver)",
 	"event WithdrawCollateral(address caller, bytes32 indexed id_, address indexed collateral, uint256 assets, address indexed onBehalf, address receiver)"
 ]);
 
@@ -2276,10 +2270,10 @@ const abi$1 = [
 	}
 ];
 const CollateralSchema = z$2.object({
-	asset: z$2.string().transform(transformAddress),
-	oracle: z$2.string().transform(transformAddress),
+	asset: AddressSchema,
+	oracle: AddressSchema,
 	lltv: LLTVSchema,
-	maxLif: z$2.bigint({ coerce: true }).min(0n).optional().default(0n)
+	maxLif: z$2.bigint({ coerce: true }).min(0n)
 });
 const CollateralsSchema = z$2.array(CollateralSchema).min(1, { message: "At least one collateral is required" }).refine((collaterals) => {
 	for (let i = 1; i < collaterals.length; i++) if (collaterals[i - 1].asset.toLowerCase() > collaterals[i].asset.toLowerCase()) return false;
@@ -2297,7 +2291,7 @@ const from$13 = (parameters) => {
 	return {
 		asset: parameters.asset.toLowerCase(),
 		lltv: from$14(parameters.lltv),
-		maxLif: parameters.maxLif ?? 0n,
+		maxLif: parameters.maxLif,
 		oracle: parameters.oracle.toLowerCase()
 	};
 };
@@ -2388,7 +2382,7 @@ function stringifyBigint(value) {
 //#endregion
 //#region src/core/Obligation.ts
 const ObligationSchema = z$2.object({
-	loanToken: z$2.string().transform(transformAddress),
+	loanToken: AddressSchema,
 	collaterals: CollateralsSchema,
 	maturity: MaturitySchema,
 	rcfThreshold: z$2.bigint({ coerce: true }).min(0n)
@@ -2431,7 +2425,8 @@ const tupleAbi = [{
 *     Collateral.from({
 *       asset: privateKeyToAccount(generatePrivateKey()).address,
 *       oracle: privateKeyToAccount(generatePrivateKey()).address,
-*       lltv: 0.965
+*       lltv: 0.965,
+*       maxLif: 0n,
 *     }),
 *   ],
 *   maturity: Maturity.from("end_of_next_quarter"),
@@ -2481,7 +2476,7 @@ function key(parameters) {
 		parameters.collaterals.map((c) => ({
 			token: c.asset.toLowerCase(),
 			lltv: c.lltv,
-			maxLif: c.maxLif ?? 0n,
+			maxLif: c.maxLif,
 			oracle: c.oracle.toLowerCase()
 		})),
 		BigInt(parameters.maturity),
@@ -2533,7 +2528,7 @@ function creationCode(parameters) {
 		collaterals: parameters.obligation.collaterals.map((collateral) => ({
 			token: collateral.asset.toLowerCase(),
 			lltv: collateral.lltv,
-			maxLif: collateral.maxLif ?? 0n,
+			maxLif: collateral.maxLif,
 			oracle: collateral.oracle.toLowerCase()
 		})),
 		maturity: BigInt(parameters.obligation.maturity),
@@ -2567,8 +2562,8 @@ let Status = /* @__PURE__ */ function(Status) {
 }({});
 const OfferSchema = () => {
 	return z$2.object({
-		maker: z$2.string().transform(transformAddress),
-		obligationUnits: z$2.bigint({ coerce: true }).min(0n).max(maxUint256).optional().default(0n),
+		maker: AddressSchema,
+		maxUnits: z$2.bigint({ coerce: true }).min(0n).max(maxUint256).optional().default(0n),
 		tick: z$2.coerce.number().int().min(0).max(990),
 		maturity: MaturitySchema,
 		rcfThreshold: z$2.bigint({ coerce: true }).min(0n).max(maxUint256),
@@ -2585,13 +2580,13 @@ const OfferSchema = () => {
 			z$2.bigint()
 		]).optional().default("0x0000000000000000000000000000000000000000000000000000000000000000").transform(transformBytes32),
 		buy: z$2.boolean(),
-		loanToken: z$2.string().transform(transformAddress),
+		loanToken: AddressSchema,
 		collaterals: CollateralsSchema,
 		callback: z$2.object({
-			address: z$2.string().transform(transformAddress),
+			address: AddressSchema,
 			data: z$2.string().transform(transformHex)
 		}),
-		receiverIfMakerIsSeller: z$2.string().transform(transformAddress),
+		receiverIfMakerIsSeller: AddressSchema,
 		exitOnly: z$2.boolean().optional().default(false)
 	}).refine((data) => data.start < data.expiry, {
 		message: "start must be before expiry",
@@ -2644,7 +2639,7 @@ function toSnakeCase(offer) {
 */
 const serialize = (offer) => ({
 	maker: offer.maker,
-	obligationUnits: offer.obligationUnits.toString(),
+	maxUnits: offer.maxUnits.toString(),
 	tick: offer.tick,
 	maturity: Number(offer.maturity),
 	rcfThreshold: offer.rcfThreshold.toString(),
@@ -2702,7 +2697,7 @@ function random(config) {
 	const loanTokenDecimals = config?.assetsDecimals?.[loanToken] ?? 18;
 	const unit = BigInt(10) ** BigInt(loanTokenDecimals);
 	const amountBase = BigInt(100 + int(999901));
-	const obligationUnitsScaled = config?.obligationUnits ?? amountBase * unit;
+	const maxUnitsScaled = config?.maxUnits ?? amountBase * unit;
 	const emptyCallback = {
 		address: zeroAddress,
 		data: "0x"
@@ -2710,7 +2705,7 @@ function random(config) {
 	const maker = config?.maker ?? address();
 	return from$11({
 		maker,
-		obligationUnits: obligationUnitsScaled,
+		maxUnits: maxUnitsScaled,
 		tick,
 		maturity,
 		rcfThreshold: config?.rcfThreshold ?? 0n,
@@ -2764,7 +2759,7 @@ function hash$1(offer) {
 *     Obligation obligation;  // nested tuple
 *     bool buy;
 *     address maker;
-*     uint256 obligationUnits;
+*     uint256 maxUnits;
 *     uint256 start;
 *     uint256 expiry;
 *     uint256 tick;
@@ -2830,7 +2825,7 @@ const OfferAbi = [{
 			type: "address"
 		},
 		{
-			name: "obligationUnits",
+			name: "maxUnits",
 			type: "uint256"
 		},
 		{
@@ -2878,7 +2873,7 @@ function encode(offer) {
 			collaterals: offer.collaterals.map((c) => ({
 				token: c.asset,
 				lltv: c.lltv,
-				maxLif: c.maxLif ?? 0n,
+				maxLif: c.maxLif,
 				oracle: c.oracle
 			})),
 			maturity: BigInt(offer.maturity),
@@ -2886,7 +2881,7 @@ function encode(offer) {
 		},
 		buy: offer.buy,
 		maker: offer.maker,
-		obligationUnits: offer.obligationUnits,
+		maxUnits: offer.maxUnits,
 		start: BigInt(offer.start),
 		expiry: BigInt(offer.expiry),
 		tick: BigInt(offer.tick),
@@ -2948,7 +2943,7 @@ const takeEvent = {
 			internalType: "uint256"
 		},
 		{
-			name: "obligationUnits",
+			name: "units",
 			type: "uint256",
 			indexed: false,
 			internalType: "uint256"
@@ -3034,7 +3029,7 @@ const repayEvent = {
 			internalType: "bytes32"
 		},
 		{
-			name: "obligationUnits",
+			name: "units",
 			type: "uint256",
 			indexed: false,
 			internalType: "uint256"
@@ -3315,24 +3310,79 @@ function assertTick(tick) {
 	if (!Number.isInteger(tick) || tick < 0 || tick > TICK_RANGE) throw new InvalidTickError(tick);
 }
 /**
-* Converts obligation units to assets using the tick price (mulDivDown).
-* @param obligationUnits - The obligation units to convert.
+* Converts units into maker-side assets using the raw tick price surface.
+* This is the public forward conversion used by the router for lot sizing and other maker-facing capacity math.
+* - `buy = true`  -> `floor(units * price / WAD)`
+* - `buy = false` -> `ceil(units * price / WAD)`
+* @param units - The units to convert.
 * @param tick - The offer tick.
-* @returns The equivalent amount in assets.
+* @param buy - Whether the maker side of the offer is buy (`true`) or sell (`false`).
+* @returns The equivalent amount in maker-side assets.
 */
-function obligationUnitsToAssets(obligationUnits, tick) {
-	return obligationUnits * tickToPrice(tick) / WAD$1;
+function unitsToAssets(units, tick, buy) {
+	const price = tickToPrice(tick);
+	return buy ? unitsToFloorAssets(units, price) : unitsToCeilAssets(units, price);
 }
 /**
-* Converts assets to obligation units using the tick price (mulDivUp).
-* @param assets - The asset amount to convert.
+* Converts a maker-side asset cap into a safe units cap using the raw tick price.
+* Buy offers use the max-safe inverse of `floor(units * price / WAD)`.
+* Sell offers use the max-safe inverse of `ceil(units * price / WAD)`.
+* The result is clamped to the remaining offer size because the asset cap may have been rounded before inversion.
+* Zero integer asset caps can still admit positive units on floor-rounded sub-WAD buy ticks, and tick=0 keeps the
+* whole remaining interval safe because the raw maker-asset surface stays at zero.
+* @param assets - The integer maker-side asset cap.
 * @param tick - The offer tick.
-* @returns The equivalent amount in obligation units.
+* @param buy - Whether the maker side of the offer is buy (`true`) or sell (`false`).
+* @param remainingUnits - The maximum units still available on the offer.
+* @returns The greatest safe units amount under the maker-side raw-price surface.
 */
-function assetsToObligationUnits(assets, tick) {
+function assetsToUnits(assets, tick, buy, remainingUnits) {
+	if (remainingUnits <= 0n) return 0n;
+	if (assets < 0n) return 0n;
 	const price = tickToPrice(tick);
-	if (price === 0n) return 0n;
-	return (assets * WAD$1 + price - 1n) / price;
+	if (price === 0n) return remainingUnits;
+	const units = buy ? floorAssetsToUnits(assets, price) : ceilAssetsToUnits(assets, price);
+	return units > remainingUnits ? remainingUnits : units;
+}
+/**
+* Forward conversion for raw-price floor surfaces.
+* This matches buy-side maker assets and the legacy floor-only helper.
+* @param units - The units to convert.
+* @param price - The raw tick price.
+* @returns The floor-rounded maker-side assets.
+*/
+function unitsToFloorAssets(units, price) {
+	return units * price / WAD$1;
+}
+/**
+* Forward conversion for raw-price ceil surfaces.
+* This matches sell-side maker assets, where the maker receives `sellerAssets` rounded up onchain.
+* @param units - The units to convert.
+* @param price - The raw tick price.
+* @returns The ceil-rounded maker-side assets.
+*/
+function unitsToCeilAssets(units, price) {
+	return (units * price + WAD$1 - 1n) / WAD$1;
+}
+/**
+* Max-safe inverse for floor surfaces.
+* It returns the greatest units value whose floor-rounded maker assets stay within `assets`.
+* @param assets - The maker-side asset cap.
+* @param price - The raw tick price.
+* @returns The greatest safe obligation-units amount under `floor(units * price / WAD) <= assets`.
+*/
+function floorAssetsToUnits(assets, price) {
+	return ((assets + 1n) * WAD$1 - 1n) / price;
+}
+/**
+* Max-safe inverse for ceil surfaces.
+* It returns the greatest units value whose ceil-rounded maker assets stay within `assets`.
+* @param assets - The maker-side asset cap.
+* @param price - The raw tick price.
+* @returns The greatest safe obligation-units amount under `ceil(units * price / WAD) <= assets`.
+*/
+function ceilAssetsToUnits(assets, price) {
+	return assets * WAD$1 / price;
 }
 var InvalidTickError = class extends BaseError {
 	name = "Tick.InvalidTickError";
@@ -3814,7 +3864,7 @@ const DEFAULT_BATCH_SIZE = 1500;
 
 //#endregion
 //#region src/database/drizzle/VERSION.ts
-const VERSION = "router_v1.15";
+const VERSION = "router_v1.16";
 
 //#endregion
 //#region src/database/drizzle/schema.ts
@@ -3962,7 +4012,7 @@ const oracles = 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" }),
-	obligationUnits: numeric("obligation_units", {
+	maxUnits: numeric("max_units", {
 		precision: 78,
 		scale: 0
 	}).notNull().default("0"),
@@ -4003,8 +4053,8 @@ const offers = s.table(EnumTableName.OFFERS, {
 	index("offers_obligation_side_tick_idx").on(table.obligationId, table.buy, table.tick),
 	index("offers_obligation_active_tick_idx").on(table.obligationId, table.buy, table.expiry, table.maturity, table.start, table.tick),
 	index("offers_group_maker_idx").on(table.groupMaker, table.hash, table.obligationId),
-	index("offers_group_winner_expr_idx").on(table.groupChainId, table.groupMaker, table.group, table.obligationId, table.buy, sql`(CASE WHEN "buy" THEN -"tick" ELSE "tick" END)`, table.blockNumber, sql`"obligation_units" DESC`, table.hash),
-	index("offers_book_winners_covering_idx").on(table.obligationId, table.buy, table.groupChainId, table.groupMaker, table.group, sql`(CASE WHEN "buy" THEN -"tick" ELSE "tick" END)`, table.blockNumber, sql`"obligation_units" DESC`, table.hash)
+	index("offers_group_winner_expr_idx").on(table.groupChainId, table.groupMaker, table.group, table.obligationId, table.buy, sql`(CASE WHEN "buy" THEN -"tick" ELSE "tick" END)`, table.blockNumber, sql`"max_units" DESC`, table.hash),
+	index("offers_book_winners_covering_idx").on(table.obligationId, table.buy, table.groupChainId, table.groupMaker, table.group, sql`(CASE WHEN "buy" THEN -"tick" ELSE "tick" END)`, table.blockNumber, sql`"max_units" DESC`, table.hash)
 ]);
 const offersCallbacks = s.table(EnumTableName.OFFERS_CALLBACKS, {
 	offerHash: varchar("offer_hash", { length: 66 }).notNull(),
@@ -4312,7 +4362,7 @@ function compositeKey(g) {
 function create$30(db) {
 	return {
 		create: async (groups$3) => {
-			if (groups$3.length === 0) return;
+			if (groups$3.length === 0) return 0;
 			const rows = groups$3.map((group) => ({
 				chainId: group.chainId,
 				maker: group.maker.toLowerCase(),
@@ -4320,7 +4370,12 @@ function create$30(db) {
 				consumed: (group.consumed ?? 0n).toString(),
 				blockNumber: group.blockNumber
 			}));
-			for (const batch of batch$1(rows, DEFAULT_BATCH_SIZE)) await db.insert(groups).values(batch).onConflictDoNothing();
+			let insertedCount = 0;
+			for (const batch of batch$1(rows, DEFAULT_BATCH_SIZE)) {
+				const inserted = await db.insert(groups).values(batch).onConflictDoNothing().returning();
+				insertedCount += inserted.length;
+			}
+			return insertedCount;
 		},
 		exists: async (groups$4) => {
 			if (groups$4.length === 0) return [];
@@ -4417,16 +4472,16 @@ const maxCollaterals = ({ max }) => single("max_collaterals", `Validates that an
 	if (offer.collaterals.length > max) return { message: `Offer has ${offer.collaterals.length} collaterals, exceeding the maximum of ${max}` };
 });
 /**
-* A validation rule that checks if the offer's obligationUnits is non-zero.
+* A validation rule that checks if the offer's maxUnits is non-zero.
 * The contract requires a positive amount; this rule rejects early.
 * @returns The issue that was found. If the offer is valid, this will be undefined.
 */
-const amountNonZero = () => single("amount_non_zero", "Validates that obligationUnits is non-zero", (offer) => {
-	if (offer.obligationUnits === 0n) return { message: "obligationUnits must be non-zero" };
+const amountNonZero = () => single("amount_non_zero", "Validates that maxUnits is non-zero", (offer) => {
+	if (offer.maxUnits === 0n) return { message: "maxUnits 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, obligationUnits,
+* All offers sharing the same group must have the same loan token, maxUnits,
 * and side (buy/sell). The contract tracks consumed per group and requires these to match.
 */
 const groupConsistency = () => batch("group_consistency", "Validates that all offers in a group have the same loan token, obligation amounts, and side", (offers) => {
@@ -4443,13 +4498,13 @@ const groupConsistency = () => batch("group_consistency", "Validates that all of
 		if (indices.length <= 1) continue;
 		const reference = offers[indices[0]];
 		const refLoanToken = reference.loanToken.toLowerCase();
-		const refUnits = reference.obligationUnits;
+		const refUnits = reference.maxUnits;
 		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.obligationUnits !== refUnits) issues.set(idx, { message: `All offers in a group must have the same obligationUnits. Expected ${refUnits}, got ${offer.obligationUnits}` });
+			else if (offer.maxUnits !== refUnits) issues.set(idx, { message: `All offers in a group must have the same maxUnits. Expected ${refUnits}, got ${offer.maxUnits}` });
 			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"}` });
 		}
 	}
@@ -4666,7 +4721,7 @@ function from$5(level) {
 	return {
 		tick: level.tick,
 		price: price.toString(),
-		obligation_units: level.obligationUnits.toString(),
+		max_units: level.maxUnits.toString(),
 		count: level.count
 	};
 }
@@ -4775,7 +4830,7 @@ function from$3(input) {
 			},
 			buy: input.buy,
 			maker: input.maker,
-			obligation_units: input.obligationUnits.toString(),
+			max_units: input.maxUnits.toString(),
 			start: input.start,
 			expiry: input.expiry,
 			tick: input.tick,
@@ -4934,7 +4989,7 @@ const offerExample = {
 		},
 		buy: false,
 		maker: "0x7b093658BE7f90B63D7c359e8f408e503c2D9401",
-		obligation_units: "369216000000000000000000",
+		max_units: "369216000000000000000000",
 		start: 1761922790,
 		expiry: 1761922799,
 		tick: 495,
@@ -4977,7 +5032,7 @@ const missingCollectorExample = {
 };
 const validateOfferExample = {
 	maker: "0x7b093658BE7f90B63D7c359e8f408e503c2D9401",
-	obligation_units: "369216000000000000000000",
+	max_units: "369216000000000000000000",
 	tick: 495,
 	maturity: 1761922799,
 	rcf_threshold: "0",
@@ -5131,8 +5186,8 @@ __decorate([ApiProperty({
 })], OfferDataResponse.prototype, "maker", void 0);
 __decorate([ApiProperty({
 	type: "string",
-	example: offerExample.offer.obligation_units
-})], OfferDataResponse.prototype, "obligation_units", void 0);
+	example: offerExample.offer.max_units
+})], OfferDataResponse.prototype, "max_units", void 0);
 __decorate([ApiProperty({
 	type: "number",
 	example: offerExample.offer.start
@@ -5386,9 +5441,9 @@ __decorate([ApiProperty({
 })], ValidateOfferRequest.prototype, "maker", void 0);
 __decorate([ApiProperty({
 	type: "string",
-	example: validateOfferExample.obligation_units,
+	example: validateOfferExample.max_units,
 	required: false
-})], ValidateOfferRequest.prototype, "obligation_units", void 0);
+})], ValidateOfferRequest.prototype, "max_units", void 0);
 __decorate([ApiProperty({
 	type: "number",
 	example: validateOfferExample.tick,
@@ -5522,7 +5577,7 @@ __decorate([ApiProperty({
 __decorate([ApiProperty({
 	type: "string",
 	example: "369216000000000000000000"
-})], BookLevelResponse.prototype, "obligation_units", void 0);
+})], BookLevelResponse.prototype, "max_units", void 0);
 __decorate([ApiProperty({
 	type: "number",
 	example: 5
@@ -7530,11 +7585,11 @@ function offerBalanceTerm(balance, price, lltv) {
 * @param lotLower - Lot lower bound (in assets).
 * @param lotUpper - Lot upper bound (in assets).
 * @param consumed - Group consumed amount (in obligation units).
-* @param obligationUnits - Offer obligation units.
+* @param maxUnits - Offer obligation units.
 */
-function lotBalance(offerBalance, offset, positionConsumed, lotLower, lotUpper, consumed, obligationUnits) {
+function lotBalance(offerBalance, offset, positionConsumed, lotLower, lotUpper, consumed, maxUnits) {
 	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 ${obligationUnits}::numeric > 0 THEN COALESCE(${consumed}::numeric, 0) * ${lotSize} / ${obligationUnits}::numeric ELSE 0 END`}))`;
+	return sql`GREATEST(0, LEAST(COALESCE(${offerBalance}, 0) + COALESCE(${offset}, 0) + COALESCE(${positionConsumed}, 0) - COALESCE(${lotLower}::numeric, 0), ${lotSize} - ${sql`CASE WHEN ${maxUnits}::numeric > 0 THEN COALESCE(${consumed}::numeric, 0) * ${lotSize} / ${maxUnits}::numeric ELSE 0 END`}))`;
 }
 /**
 * Callback contribution: amount contributed by one callback in loan terms.
@@ -7546,17 +7601,23 @@ function contribution(lotBalance, lotLower) {
 	return sql`CASE WHEN ${lotLower} IS NULL THEN 0 ELSE ${lotBalance} END`;
 }
 /**
-* Takeable amount in assets.
-* Converts the obligation-unit capacity to assets using the tick price,
-* then compares with available (already in assets from lot balance).
-* @param obligationUnits - Offer obligation units.
+* Takeable amount in maker-side assets.
+* Buy offers use the floor maker-asset surface for remaining obligation units.
+* Sell offers use the ceil maker-asset surface for remaining obligation units.
+* The result is then compared with available (already in assets from lot balance).
+* @param maxUnits - Offer obligation units.
 * @param consumed - Group consumed amount (in obligation units).
 * @param available - Total available from callbacks/positions (in assets).
 * @param price - Tick price (from tick_prices CTE).
+* @param buy - Offer side (`true` for buy, `false` for sell).
 */
-function takeable(obligationUnits, consumed, available, price) {
+function takeable(maxUnits, consumed, available, price, buy) {
 	const WAD_SQL = sql`(10::numeric ^ 18)`;
-	return sql`GREATEST(0, LEAST(${sql`(${sql`(${obligationUnits}::numeric * ${price} / ${WAD_SQL})`} - ${sql`(${consumed}::numeric * ${price} / ${WAD_SQL})`})`}, ${available}))`;
+	const remainingUnits = sql`GREATEST(COALESCE(${maxUnits}::numeric, 0) - COALESCE(${consumed}::numeric, 0), 0)`;
+	return sql`GREATEST(0, LEAST(${sql`CASE WHEN ${buy}
+    THEN TRUNC(${remainingUnits} * COALESCE(${price}::numeric, 0) / ${WAD_SQL})
+    ELSE CEIL(${remainingUnits} * COALESCE(${price}::numeric, 0) / ${WAD_SQL})
+  END`}, ${available}))`;
 }
 /** Precomputed tick→price lookup (all 991 ticks). */
 const TICK_PRICES = Array.from({ length: TICK_RANGE + 1 }, (_, i) => [i, tickToPrice(i).toString()]);
@@ -7588,7 +7649,7 @@ function offerAvailabilityCTEs(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.obligation_units
+        o.group_chain_id, o.group_maker, o.group_group, o.obligation_id, o.buy, o.max_units
       FROM ${offers} o
       LEFT JOIN ${validations} v
         ON v.offer_hash = o.hash
@@ -7605,7 +7666,7 @@ function offerAvailabilityCTEs(params) {
       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.obligation_units DESC, o.hash ASC
+        o.block_number ASC, o.max_units DESC, o.hash ASC
     ),
     relevant_positions AS (
       SELECT DISTINCT c.position_chain_id, c.position_contract, c.position_user
@@ -7630,8 +7691,8 @@ function offerAvailabilityCTEs(params) {
         COALESCE(
           SUM(
             CASE
-              WHEN wo.obligation_units::numeric > 0
-              THEN COALESCE(g.consumed::numeric, 0) * (l.upper::numeric - l.lower::numeric) / wo.obligation_units::numeric
+              WHEN wo.max_units::numeric > 0
+              THEN COALESCE(g.consumed::numeric, 0) * (l.upper::numeric - l.lower::numeric) / wo.max_units::numeric
               ELSE 0
             END
           ) OVER (
@@ -7678,14 +7739,14 @@ function offerAvailabilityCTEs(params) {
         src.obligation_id,
         src.group_group,
         src.consumed,
-        src.obligation_units,
+        src.max_units,
         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.obligation_units`)} AS lot_balance
+        ${lotBalance(sql`vb.offer_balance`, sql`pos_offsets.total_offset`, sql`pc.consumed`, sql`l.lower`, sql`l.upper`, sql`src.consumed`, sql`src.max_units`)} AS lot_balance
       FROM ${source} src
       LEFT JOIN ${offersCallbacks} oc
         ON oc.offer_hash = src.hash
@@ -7753,7 +7814,7 @@ function offerTakeabilityCTEs(params) {
     offer_takeable AS (
       SELECT src.hash, src.obligation_id,
         COALESCE(oa.available, 0) AS available,
-        ${takeable(sql`src.obligation_units`, sql`src.consumed`, sql`COALESCE(oa.available, 0)`, sql`tp.price`)} AS takeable
+        ${takeable(sql`src.max_units`, sql`src.consumed`, sql`COALESCE(oa.available, 0)`, sql`tp.price`, sql`src.buy`)} AS takeable
       FROM ${source} src
       LEFT JOIN offer_available oa ON oa.hash = src.hash AND oa.obligation_id = src.obligation_id
       LEFT JOIN tick_prices tp ON tp.tick = src.tick
@@ -7892,7 +7953,7 @@ function create$27(config) {
 	const db = config.db;
 	const logger = getLogger();
 	const getOffers = async (parameters) => {
-		const { side, obligationId, cursor: cursorString } = parameters;
+		const { side, obligationId, cursor: cursorString, requirePositiveTakeableAssets = false } = parameters;
 		const requestedLimit = parameters.limit ?? DEFAULT_LIMIT$4;
 		const priceSortDirection = side === "sell" ? "asc" : "desc";
 		const inputCursor = Cursor.decode(cursorString, logger);
@@ -7913,7 +7974,8 @@ function create$27(config) {
 			now,
 			priceSortDirection,
 			cursor: inputCursor,
-			limit: Math.min(requestedLimit, MAX_TOTAL_OFFERS - previouslyReturned)
+			limit: Math.min(requestedLimit, MAX_TOTAL_OFFERS - previouslyReturned),
+			requirePositiveTakeableAssets
 		});
 		const lastReturnedOffer = rows[rows.length - 1];
 		const newTotalReturned = previouslyReturned + rows.length;
@@ -7945,16 +8007,16 @@ function create$27(config) {
 			for (const row of rows) {
 				const existing = tickMap.get(row.tick);
 				if (existing) {
-					existing.obligationUnits += row.takeable;
+					existing.maxUnits += row.takeable;
 					existing.count += 1;
 				} else tickMap.set(row.tick, {
-					obligationUnits: row.takeable,
+					maxUnits: row.takeable,
 					count: 1
 				});
 			}
 			const levels = Array.from(tickMap.entries()).map(([tick, level]) => ({
 				tick,
-				obligationUnits: level.obligationUnits,
+				maxUnits: level.maxUnits,
 				count: level.count
 			}));
 			levels.sort((a, b) => tickSortDirection === "asc" ? a.tick - b.tick : b.tick - a.tick);
@@ -7971,15 +8033,15 @@ function create$27(config) {
 }
 /** Get offers with computed takeable based on lot balance. */
 async function _getOffers(db, params) {
-	const { obligationId, side, now, priceSortDirection, cursor, limit } = params;
+	const { obligationId, side, now, priceSortDirection, cursor, limit, requirePositiveTakeableAssets } = params;
 	const raw = await db.execute(sql`
     WITH collats AS MATERIALIZED (
       SELECT oia.obligation_id,
             COALESCE(jsonb_agg(jsonb_build_object(
               'asset',  oc.asset,
               'oracle', oc.oracle_address,
-              'lltv',   oc.lltv,
-              'maxLif', oc.max_lif
+              'lltv',   oc.lltv::text,
+              'maxLif', oc.max_lif::text
             ) ORDER BY oc.asset), '[]'::jsonb) AS collaterals
       FROM ${obligationIdKeys} oia
       JOIN ${obligationCollateralsV2} oc
@@ -8004,7 +8066,7 @@ async function _getOffers(db, params) {
         AND (s.code IS NULL OR s.code = ${Status.VALID})
       ORDER BY
         o.group_chain_id, o.group_maker, o."group_group",
-        CASE WHEN o.buy THEN -o.tick ELSE o.tick END ASC, o.block_number ASC, o.obligation_units DESC, o.hash ASC
+        CASE WHEN o.buy THEN -o.tick ELSE o.tick END ASC, o.block_number ASC, o.max_units DESC, o.hash ASC
     ),
     enriched AS (
       SELECT
@@ -8013,7 +8075,7 @@ async function _getOffers(db, params) {
         CASE WHEN ${priceSortDirection === "asc" ? sql`TRUE` : sql`FALSE`}
           THEN w.tick ELSE -w.tick END AS tick_norm,
         w.block_number AS block_norm,
-        -w.obligation_units AS obligation_units_norm,
+        -w.max_units AS max_units_norm,
         w.hash AS hash_norm
       FROM winners w
       JOIN ${groups} g
@@ -8034,24 +8096,34 @@ async function _getOffers(db, params) {
       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
+      WHERE (
+        ot.takeable > 0
+        OR (
+          COALESCE(e.max_units::numeric, 0) > COALESCE(e.consumed::numeric, 0)
+          AND (
+            e.tick = 0
+            OR (e.buy AND e.tick < ${TICK_RANGE})
+          )
+        )
+      )
+      ${requirePositiveTakeableAssets ? sql`AND TRUNC(COALESCE(ot.takeable, 0)::numeric) > 0` : sql``}
       ${cursor != null ? sql`
-        AND (e.tick_norm, e.block_norm, e.obligation_units_norm, e.hash_norm)
+        AND (e.tick_norm, e.block_norm, e.max_units_norm, e.hash_norm)
           > (
               CASE WHEN ${priceSortDirection === "asc" ? sql`TRUE` : sql`FALSE`}
                 THEN ${cursor.tick}::integer ELSE -${cursor.tick}::integer END,
               ${cursor.blockNumber},
-              -${cursor.obligationUnits}::numeric,
+              -${cursor.maxUnits}::numeric,
               ${cursor.hash}
             )` : sql``}
-      ORDER BY e.tick ${priceSortDirection === "asc" ? sql`ASC` : sql`DESC`}, e.block_number ASC, e.obligation_units DESC, e.hash ASC
+      ORDER BY e.tick ${priceSortDirection === "asc" ? sql`ASC` : sql`DESC`}, e.block_number ASC, e.max_units DESC, e.hash ASC
       LIMIT ${limit}
     )
     SELECT
       p.hash,
       p.obligation_id,
       p.group_maker,
-      p.obligation_units,
+      p.max_units,
       p.consumed,
       p.tick,
       p.maturity,
@@ -8081,17 +8153,20 @@ async function _getOffers(db, params) {
     ORDER BY
       p.tick ${priceSortDirection === "asc" ? sql`ASC` : sql`DESC`},
       p.block_number ASC,
-      p.obligation_units DESC,
+      p.max_units DESC,
       p.hash ASC;
   `);
 	return {
 		rows: raw.rows.map((row) => {
 			const receiverIfMakerIsSeller = (row.receiver_if_maker_is_seller ?? row.group_maker).toLowerCase();
+			const maxUnits = BigInt(row.max_units ?? 0);
+			const consumed = BigInt(row.consumed ?? 0);
+			const remainingUnits = maxUnits > consumed ? maxUnits - consumed : 0n;
 			return {
 				hash: row.hash,
 				obligationId: row.obligation_id,
 				maker: row.group_maker,
-				obligationUnits: BigInt(row.obligation_units ?? 0),
+				maxUnits,
 				tick: row.tick,
 				maturity: row.maturity,
 				expiry: row.expiry,
@@ -8106,7 +8181,7 @@ async function _getOffers(db, params) {
 					asset: c.asset,
 					oracle: c.oracle,
 					lltv: BigInt(c.lltv),
-					maxLif: BigInt(c.maxLif ?? 0)
+					maxLif: BigInt(c.maxLif)
 				})),
 				callback: {
 					address: row.callback_address,
@@ -8115,9 +8190,9 @@ async function _getOffers(db, params) {
 				receiverIfMakerIsSeller,
 				exitOnly: row.exit_only,
 				blockNumber: row.block_number,
-				consumed: BigInt(row.consumed ?? 0),
+				consumed,
 				available: BigInt(String(row.available ?? "0").split(".")[0] ?? "0"),
-				takeable: assetsToObligationUnits(BigInt(String(row.takeable).split(".")[0] ?? "0"), row.tick),
+				takeable: assetsToUnits(BigInt(String(row.takeable).split(".")[0] ?? "0"), row.tick, row.buy, remainingUnits),
 				root: row.tree_root ? row.tree_root.toLowerCase() : void 0,
 				signature: row.root_signature ? row.root_signature.toLowerCase() : void 0,
 				proof: row.proof_nodes ? splitProofs(row.proof_nodes) : void 0
@@ -8133,7 +8208,7 @@ let Cursor;
 			side,
 			tick: row.tick,
 			blockNumber: row.blockNumber,
-			obligationUnits: row.obligationUnits.toString(),
+			maxUnits: row.maxUnits.toString(),
 			hash: row.hash,
 			totalReturned,
 			now
@@ -8144,7 +8219,7 @@ let Cursor;
 		if (cursorString == null) return null;
 		try {
 			const v = JSON.parse(Buffer.from(cursorString, "base64url").toString("utf8"));
-			if ((v?.side === "buy" || v?.side === "sell") && typeof v?.tick === "number" && Number.isInteger(v.tick) && typeof v?.blockNumber === "number" && Number.isInteger(v.blockNumber) && typeof v?.obligationUnits === "string" && /^-?\d+$/.test(v.obligationUnits) && isHex(v?.hash) && typeof v?.totalReturned === "number" && Number.isInteger(v.totalReturned) && typeof v?.now === "number" && Number.isInteger(v.now)) return v;
+			if ((v?.side === "buy" || v?.side === "sell") && typeof v?.tick === "number" && Number.isInteger(v.tick) && typeof v?.blockNumber === "number" && Number.isInteger(v.blockNumber) && typeof v?.maxUnits === "string" && /^-?\d+$/.test(v.maxUnits) && isHex(v?.hash) && typeof v?.totalReturned === "number" && Number.isInteger(v.totalReturned) && typeof v?.now === "number" && Number.isInteger(v.now)) return v;
 			throw new Error("Invalid cursor");
 		} catch {
 			logger.error({
@@ -8196,7 +8271,10 @@ let LevelCursor;
 function create$26(db) {
 	return {
 		upsert: async (inputs) => {
-			if (inputs.length === 0) return;
+			if (inputs.length === 0) return {
+				callbacksInserted: 0,
+				offersCallbacksInserted: 0
+			};
 			const idCache = /* @__PURE__ */ new Map();
 			const seenCallbackIds = /* @__PURE__ */ new Set();
 			const callbacksRows = [];
@@ -8236,7 +8314,10 @@ function create$26(db) {
 					});
 				}
 			}
-			if (offersCallbacksRows.length === 0) return;
+			if (offersCallbacksRows.length === 0) return {
+				callbacksInserted: 0,
+				offersCallbacksInserted: 0
+			};
 			const offerHashes = [...new Set(offersCallbacksRows.map((r) => r.offerHash))];
 			const existingOffers = await db.select({
 				hash: offers.hash,
@@ -8244,10 +8325,25 @@ function create$26(db) {
 			}).from(offers).where(inArray(offers.hash, offerHashes));
 			const existingKeys = new Set(existingOffers.map((r) => `${String(r.hash).toLowerCase()}:${String(r.obligationId).toLowerCase()}`));
 			const filteredOffersCallbacksRows = offersCallbacksRows.filter((r) => existingKeys.has(`${r.offerHash}:${r.obligationId}`));
-			if (filteredOffersCallbacksRows.length === 0) return;
-			await db.transaction(async (dbTx) => {
-				for (const batch of batch$1(callbacksRows, DEFAULT_BATCH_SIZE)) await dbTx.insert(callbacks).values(batch).onConflictDoNothing();
-				for (const batch of batch$1(filteredOffersCallbacksRows, DEFAULT_BATCH_SIZE)) await dbTx.insert(offersCallbacks).values(batch).onConflictDoNothing();
+			if (filteredOffersCallbacksRows.length === 0) return {
+				callbacksInserted: 0,
+				offersCallbacksInserted: 0
+			};
+			return await db.transaction(async (dbTx) => {
+				let callbacksInserted = 0;
+				for (const batch of batch$1(callbacksRows, DEFAULT_BATCH_SIZE)) {
+					const inserted = await dbTx.insert(callbacks).values(batch).onConflictDoNothing().returning();
+					callbacksInserted += inserted.length;
+				}
+				let offersCallbacksInserted = 0;
+				for (const batch of batch$1(filteredOffersCallbacksRows, DEFAULT_BATCH_SIZE)) {
+					const inserted = await dbTx.insert(offersCallbacks).values(batch).onConflictDoNothing().returning();
+					offersCallbacksInserted += inserted.length;
+				}
+				return {
+					callbacksInserted,
+					offersCallbacksInserted
+				};
 			});
 		},
 		delete: async ({ offers }) => {
@@ -8263,7 +8359,10 @@ function create$26(db) {
 function create$25(db) {
 	return {
 		create: async (events) => {
-			if (events.length === 0) return;
+			if (events.length === 0) return {
+				groupsInserted: 0,
+				consumedEventsInserted: 0
+			};
 			const groups$2 = /* @__PURE__ */ new Map();
 			for (const event of events) {
 				const groupId = `${event.chainId}-${event.maker}-${event.group}`.toLowerCase();
@@ -8274,7 +8373,7 @@ function create$25(db) {
 					blockNumber: event.blockNumber
 				});
 			}
-			await db.transaction(async (dbTx) => {
+			return await db.transaction(async (dbTx) => {
 				const groupsRows = Array.from(groups$2.values()).map((group) => ({
 					chainId: group.chainId,
 					maker: group.maker.toLowerCase(),
@@ -8282,7 +8381,11 @@ function create$25(db) {
 					consumed: "0",
 					blockNumber: group.blockNumber
 				}));
-				for (const batch of batch$1(groupsRows, DEFAULT_BATCH_SIZE)) await dbTx.insert(groups).values(batch).onConflictDoNothing();
+				let groupsInserted = 0;
+				for (const batch of batch$1(groupsRows, DEFAULT_BATCH_SIZE)) {
+					const inserted = await dbTx.insert(groups).values(batch).onConflictDoNothing().returning();
+					groupsInserted += inserted.length;
+				}
 				const eventsRows = events.map((event) => ({
 					eventId: event.id,
 					chainId: event.chainId,
@@ -8291,7 +8394,15 @@ function create$25(db) {
 					amount: event.amount.toString(),
 					blockNumber: event.blockNumber
 				}));
-				for (const batch of batch$1(eventsRows, DEFAULT_BATCH_SIZE)) await dbTx.insert(consumedEvents).values(batch).onConflictDoNothing();
+				let consumedEventsInserted = 0;
+				for (const batch of batch$1(eventsRows, DEFAULT_BATCH_SIZE)) {
+					const inserted = await dbTx.insert(consumedEvents).values(batch).onConflictDoNothing().returning();
+					consumedEventsInserted += inserted.length;
+				}
+				return {
+					groupsInserted,
+					consumedEventsInserted
+				};
 			});
 		},
 		delete: async (parameters) => {
@@ -8324,7 +8435,10 @@ function create$24(db) {
 			}));
 		},
 		create: async (parameters) => {
-			if (parameters.length === 0) return;
+			if (parameters.length === 0) return {
+				lotsPositionsInserted: 0,
+				lotsInserted: 0
+			};
 			const lotsByKey = /* @__PURE__ */ new Map();
 			for (const offer of parameters) {
 				const key = `${offer.positionChainId}-${offer.positionContract}-${offer.positionUser}-${offer.group}-${offer.obligationId}`.toLowerCase();
@@ -8342,7 +8456,10 @@ function create$24(db) {
 				const groupKey = `${offer.positionChainId}-${offer.positionUser.toLowerCase()}-${offer.group.toLowerCase()}`;
 				if (!existingGroupKeys.has(groupKey)) lotsByKey.delete(key);
 			}
-			if (lotsByKey.size === 0) return;
+			if (lotsByKey.size === 0) return {
+				lotsPositionsInserted: 0,
+				lotsInserted: 0
+			};
 			const positionsByKey = /* @__PURE__ */ new Map();
 			for (const offer of lotsByKey.values()) {
 				const posKey = `${offer.positionChainId}-${offer.positionContract}-${offer.positionUser}`.toLowerCase();
@@ -8353,12 +8470,17 @@ function create$24(db) {
 					positionTypeId: offer.positionTypeId
 				});
 			}
-			for (const row of positionsByKey.values()) await db.insert(lotsPositions).values(row).onConflictDoNothing();
+			let lotsPositionsInserted = 0;
+			for (const row of positionsByKey.values()) {
+				const inserted = await db.insert(lotsPositions).values(row).onConflictDoNothing().returning();
+				lotsPositionsInserted += inserted.length;
+			}
+			let lotsInserted = 0;
 			for (const offer of lotsByKey.values()) if ((await db.select().from(lots).where(and(eq(lots.chainId, offer.positionChainId), eq(lots.contract, offer.positionContract.toLowerCase()), eq(lots.user, offer.positionUser.toLowerCase()), eq(lots.group, offer.group.toLowerCase()), eq(lots.obligationId, offer.obligationId.toLowerCase()))).limit(1)).length === 0) {
 				const maxUpperResult = await db.select({ maxUpper: sql`COALESCE(MAX(${lots.upper}::numeric), 0)` }).from(lots).where(and(eq(lots.chainId, offer.positionChainId), eq(lots.contract, offer.positionContract.toLowerCase()), eq(lots.user, offer.positionUser.toLowerCase()), eq(lots.obligationId, offer.obligationId.toLowerCase())));
 				const newLower = BigInt(maxUpperResult[0]?.maxUpper ?? "0");
 				const newUpper = newLower + offer.size;
-				await db.insert(lots).values({
+				const inserted = await db.insert(lots).values({
 					chainId: offer.positionChainId,
 					user: offer.positionUser.toLowerCase(),
 					contract: offer.positionContract.toLowerCase(),
@@ -8366,8 +8488,13 @@ function create$24(db) {
 					obligationId: offer.obligationId.toLowerCase(),
 					lower: newLower.toString(),
 					upper: newUpper.toString()
-				});
+				}).returning();
+				lotsInserted += inserted.length;
 			}
+			return {
+				lotsPositionsInserted,
+				lotsInserted
+			};
 		}
 	};
 }
@@ -8389,7 +8516,7 @@ function create$23(db) {
 				chainId: obligationIdKeys.chainId,
 				morphoV2: obligationIdKeys.morphoV2,
 				loanToken: obligations.loanToken,
-				collaterals: sql`ARRAY_AGG(jsonb_build_object('asset', ${obligationCollateralsV2.asset}, 'oracle', ${obligationCollateralsV2.oracleAddress}, 'lltv', ${obligationCollateralsV2.lltv}, 'maxLif', ${obligationCollateralsV2.maxLif}))`.as("collaterals"),
+				collaterals: sql`ARRAY_AGG(jsonb_build_object('asset', ${obligationCollateralsV2.asset}, 'oracle', ${obligationCollateralsV2.oracleAddress}, 'lltv', ${obligationCollateralsV2.lltv}::text, 'maxLif', ${obligationCollateralsV2.maxLif}::text))`.as("collaterals"),
 				maturity: obligations.maturity,
 				rcfThreshold: obligations.rcfThreshold
 			}).from(obligationIdKeys).innerJoin(obligations, eq(obligationIdKeys.obligationKey, obligations.obligationKey)).innerJoin(obligationCollateralsV2, eq(obligations.obligationKey, obligationCollateralsV2.obligationKey)).groupBy(obligationIdKeys.obligationId, obligationIdKeys.chainId, obligationIdKeys.morphoV2, obligations.loanToken, obligations.maturity, obligations.rcfThreshold).where(and(chainIds !== void 0 && chainIds.length > 0 ? inArray(obligationIdKeys.chainId, chainIds) : void 0, gte(obligations.maturity, now$3))).orderBy(asc(obligationIdKeys.obligationId))).map((row) => ({
@@ -8402,7 +8529,7 @@ function create$23(db) {
 						asset: collateral.asset,
 						oracle: collateral.oracle,
 						lltv: from$14(BigInt(collateral.lltv)),
-						maxLif: BigInt(collateral.maxLif ?? 0)
+						maxLif: BigInt(collateral.maxLif)
 					})),
 					maturity: row.maturity,
 					rcfThreshold: BigInt(row.rcfThreshold)
@@ -8410,7 +8537,11 @@ function create$23(db) {
 			}));
 		},
 		create: async (obligations$1) => {
-			if (obligations$1.length === 0) return;
+			if (obligations$1.length === 0) return {
+				obligationsInserted: 0,
+				obligationIdKeysInserted: 0,
+				obligationCollateralsInserted: 0
+			};
 			const obligationsByKey = /* @__PURE__ */ new Map();
 			const obligationIdKeysById = /* @__PURE__ */ new Map();
 			for (const input of obligations$1) {
@@ -8420,32 +8551,49 @@ function create$23(db) {
 				if (!obligationIdKeysById.has(obligationId)) obligationIdKeysById.set(obligationId, input);
 			}
 			try {
-				await db.transaction(async (dbTx) => {
+				return await db.transaction(async (dbTx) => {
 					const obligationRows = Array.from(obligationsByKey.entries()).map(([obligationKey, item]) => ({
 						obligationKey,
 						loanToken: item.loanToken.toLowerCase(),
 						maturity: item.maturity,
 						rcfThreshold: item.rcfThreshold.toString()
 					}));
-					for (const batch of batch$1(obligationRows, DEFAULT_BATCH_SIZE)) await dbTx.insert(obligations).values(batch).onConflictDoNothing();
+					let obligationsInserted = 0;
+					for (const batch of batch$1(obligationRows, DEFAULT_BATCH_SIZE)) {
+						const inserted = await dbTx.insert(obligations).values(batch).onConflictDoNothing().returning();
+						obligationsInserted += inserted.length;
+					}
 					const obligationIdKeyRows = Array.from(obligationIdKeysById.entries()).map(([obligationId, input]) => ({
 						obligationId,
 						obligationKey: key(input.obligation).toLowerCase(),
 						chainId: input.chainId,
 						morphoV2: input.morphoV2.toLowerCase()
 					}));
-					for (const batch of batch$1(obligationIdKeyRows, DEFAULT_BATCH_SIZE)) await dbTx.insert(obligationIdKeys).values(batch).onConflictDoNothing();
+					let obligationIdKeysInserted = 0;
+					for (const batch of batch$1(obligationIdKeyRows, DEFAULT_BATCH_SIZE)) {
+						const inserted = await dbTx.insert(obligationIdKeys).values(batch).onConflictDoNothing().returning();
+						obligationIdKeysInserted += inserted.length;
+					}
 					const collateralRows = Array.from(obligationsByKey.entries()).flatMap(([obligationKey, item]) => {
 						return [...item.collaterals].sort((a, b) => a.asset.toLowerCase().localeCompare(b.asset.toLowerCase())).map((collateral, collateralIndex) => ({
 							obligationKey,
 							asset: collateral.asset.toLowerCase(),
 							oracleAddress: collateral.oracle.toLowerCase(),
 							lltv: collateral.lltv,
-							maxLif: collateral.maxLif ?? 0n,
+							maxLif: collateral.maxLif,
 							collateralIndex
 						}));
 					});
-					for (const batch of batch$1(collateralRows, DEFAULT_BATCH_SIZE)) await dbTx.insert(obligationCollateralsV2).values(batch).onConflictDoNothing();
+					let obligationCollateralsInserted = 0;
+					for (const batch of batch$1(collateralRows, DEFAULT_BATCH_SIZE)) {
+						const inserted = await dbTx.insert(obligationCollateralsV2).values(batch).onConflictDoNothing().returning();
+						obligationCollateralsInserted += inserted.length;
+					}
+					return {
+						obligationsInserted,
+						obligationIdKeysInserted,
+						obligationCollateralsInserted
+					};
 				});
 			} catch (err) {
 				const error = err instanceof Error ? err : new Error(String(err));
@@ -8529,8 +8677,8 @@ function create$22(config) {
           jsonb_build_object(
             'asset', ${obligationCollateralsV2.asset},
             'oracle', ${obligationCollateralsV2.oracleAddress},
-            'lltv', ${obligationCollateralsV2.lltv},
-            'maxLif', ${obligationCollateralsV2.maxLif}
+            'lltv', ${obligationCollateralsV2.lltv}::text,
+            'maxLif', ${obligationCollateralsV2.maxLif}::text
           )
         ),
         '[]'::jsonb
@@ -8539,7 +8687,7 @@ function create$22(config) {
 				hash: offers.hash,
 				obligationId: offers.obligationId,
 				maker: offers.groupMaker,
-				obligationUnits: offers.obligationUnits,
+				maxUnits: offers.maxUnits,
 				tick: offers.tick,
 				maturity: offers.maturity,
 				rcfThreshold: obligations.rcfThreshold,
@@ -8562,7 +8710,7 @@ function create$22(config) {
 					hash: row.hash,
 					obligationId: row.obligationId,
 					maker: row.maker,
-					obligationUnits: BigInt(row.obligationUnits),
+					maxUnits: BigInt(row.maxUnits),
 					tick: row.tick,
 					maturity: from$15(row.maturity),
 					rcfThreshold: BigInt(row.rcfThreshold),
@@ -8577,7 +8725,7 @@ function create$22(config) {
 						asset: c.asset,
 						oracle: c.oracle,
 						lltv: BigInt(c.lltv),
-						maxLif: BigInt(c.maxLif ?? 0)
+						maxLif: BigInt(c.maxLif)
 					})).sort((a, b) => a.asset.toLowerCase().localeCompare(b.asset.toLowerCase())),
 					callback: {
 						address: row.callbackAddress,
@@ -8702,25 +8850,30 @@ function create$20(db) {
 			}));
 		},
 		upsert: async (oracles$2) => {
-			if (oracles$2.length === 0) return;
+			if (oracles$2.length === 0) return 0;
 			const rows = oracles$2.map((o) => ({
 				chainId: o.chainId,
 				address: o.address.toLowerCase(),
 				price: o.price !== null ? o.price.toString() : null,
 				blockNumber: o.blockNumber
 			}));
-			await db.transaction(async (dbTx) => {
-				for (const batch of batch$1(rows, DEFAULT_BATCH_SIZE)) await dbTx.insert(oracles).values(batch).onConflictDoUpdate({
-					target: [oracles.chainId, oracles.address],
-					set: {
-						price: sql`COALESCE(EXCLUDED.price, ${oracles.price})`,
-						blockNumber: sql`CASE
+			return await db.transaction(async (dbTx) => {
+				let upsertedCount = 0;
+				for (const batch of batch$1(rows, DEFAULT_BATCH_SIZE)) {
+					const upserted = await dbTx.insert(oracles).values(batch).onConflictDoUpdate({
+						target: [oracles.chainId, oracles.address],
+						set: {
+							price: sql`COALESCE(EXCLUDED.price, ${oracles.price})`,
+							blockNumber: sql`CASE
                   WHEN EXCLUDED.price IS NULL THEN ${oracles.blockNumber}
                   ELSE EXCLUDED.block_number
                 END`,
-						updatedAt: sql`NOW()`
-					}
-				});
+							updatedAt: sql`NOW()`
+						}
+					}).returning();
+					upsertedCount += upserted.length;
+				}
+				return upsertedCount;
 			});
 		}
 	};
@@ -8859,8 +9012,8 @@ const create$19 = (db) => {
             l.obligation_id,
             SUM(
               CASE
-                WHEN offer_agg.obligation_units > 0
-                THEN COALESCE(g.consumed::numeric, 0) * (l.upper::numeric - l.lower::numeric) / offer_agg.obligation_units
+                WHEN offer_agg.max_units > 0
+                THEN COALESCE(g.consumed::numeric, 0) * (l.upper::numeric - l.lower::numeric) / offer_agg.max_units
                 ELSE 0
               END
             ) AS consumed
@@ -8875,7 +9028,7 @@ const create$19 = (db) => {
               group_maker,
               "group_group",
               obligation_id,
-              MAX(obligation_units::numeric) AS obligation_units
+              MAX(max_units::numeric) AS max_units
             FROM ${offers}
             GROUP BY group_chain_id, group_maker, "group_group", obligation_id
           ) offer_agg
@@ -9318,7 +9471,7 @@ function create$16(parameters) {
 			obligationId: obligationIdKeys.obligationId,
 			chainId: obligationIdKeys.chainId,
 			loanToken: obligations.loanToken,
-			collaterals: sql`ARRAY_AGG(jsonb_build_object('asset', ${obligationCollateralsV2.asset}, 'oracle', ${obligationCollateralsV2.oracleAddress}, 'lltv', ${obligationCollateralsV2.lltv}))`.as("collaterals"),
+			collaterals: sql`ARRAY_AGG(jsonb_build_object('asset', ${obligationCollateralsV2.asset}, 'oracle', ${obligationCollateralsV2.oracleAddress}, 'lltv', ${obligationCollateralsV2.lltv}::text, 'maxLif', ${obligationCollateralsV2.maxLif}::text))`.as("collaterals"),
 			maturity: obligations.maturity,
 			rcfThreshold: obligations.rcfThreshold,
 			askTick: sql`MAX(${bestQuotes.askTick})`.as("ask_tick"),
@@ -9351,7 +9504,8 @@ function create$16(parameters) {
 				collaterals: row.collaterals.sort((left, right) => left.asset.localeCompare(right.asset)).map((collateral) => from$13({
 					asset: collateral.asset,
 					oracle: collateral.oracle,
-					lltv: from$14(BigInt(collateral.lltv))
+					lltv: from$14(BigInt(collateral.lltv)),
+					maxLif: BigInt(collateral.maxLif)
 				})),
 				maturity: row.maturity,
 				rcfThreshold: BigInt(row.rcfThreshold)
@@ -9811,7 +9965,7 @@ async function postMigrate(driver) {
       WHERE o.group_chain_id = t.chain_id
         AND o.group_maker    = t.maker
         AND o.group_group    = t."group"
-        AND o.obligation_units <= t.consumed;
+        AND o.max_units <= t.consumed;
       RETURN NULL;
     END;
     $$;
@@ -9840,7 +9994,7 @@ async function postMigrate(driver) {
         AND g.chain_id       = t.group_chain_id
         AND g.maker          = t.group_maker
         AND g."group"        = t."group"
-        AND o.obligation_units <= g.consumed;
+        AND o.max_units <= g.consumed;
       RETURN NULL;
     END;
     $$;`);
@@ -10452,6 +10606,7 @@ const INDEXED_EVENT_PREFIX = "indexer.collector.";
 const INDEXED_EVENT_SUFFIX$1 = "_indexed";
 const LOGS_INGESTED_TOTAL_METRIC = "router_indexer_logs_ingested_total";
 const LOGS_INDEXED_TOTAL_METRIC = "router_indexer_logs_indexed_total";
+const LOGS_DROPPED_TOTAL_METRIC = "router_indexer_logs_dropped_total";
 const LOG_ENTRIES_TOTAL_METRIC = "router_indexer_log_entries_total";
 const TICK_DURATION_SECONDS_METRIC = "router_indexer_tick_duration_seconds";
 const TICK_PHASE_DURATION_SECONDS_METRIC = "router_indexer_tick_phase_duration_seconds";
@@ -10460,6 +10615,7 @@ const CHAIN_RPC_HEAD_AGE_SECONDS_METRIC = "router_indexer_chain_rpc_head_age_sec
 const CHAIN_RPC_HEAD_UNAVAILABLE_TOTAL_METRIC = "router_indexer_chain_rpc_head_unavailable_total";
 const ENTITIES_COMMITTED_TOTAL_METRIC = "router_indexer_entities_committed_total";
 const ENTITIES_ATTEMPTED_TOTAL_METRIC = "router_indexer_entities_attempted_total";
+const DB_ROWS_COMMITTED_TOTAL_METRIC = "router_indexer_db_rows_committed_total";
 const ENTITY_COMMIT_LAST_UNIXTIME_METRIC = "router_indexer_entity_commit_last_unixtime";
 const COLLECTOR_COMMIT_LAST_UNIXTIME_METRIC = "router_indexer_collector_commit_last_unixtime";
 const tickDurationBucketsSeconds = [
@@ -10517,6 +10673,11 @@ const chainSyncModeLabels = [
 	"unknown"
 ];
 const headToDbLatencyExcludedEvents = new Set([INDEXER_COLLECTOR_TRANSFERS_INDEXED]);
+const droppedLogEvents = new Set([
+	INDEXER_COLLECTOR_OFFER_TREE_DECODE_FAILED,
+	INDEXER_COLLECTOR_OFFER_TREE_REJECTED,
+	INDEXER_COLLECTOR_LOG_SKIPPED
+]);
 const collectorNameByIndexedEvent$1 = new Map([
 	[INDEXER_COLLECTOR_OFFERS_INDEXED, "offers"],
 	[INDEXER_COLLECTOR_EVENTS_INDEXED, "morpho_v2"],
@@ -10541,6 +10702,16 @@ function create$15() {
 		labelNames: ["chain_id", "collector"],
 		registers: [registry]
 	});
+	const logsDroppedTotal = new Counter({
+		name: LOGS_DROPPED_TOTAL_METRIC,
+		help: "Total collector inputs dropped for stable reasons.",
+		labelNames: [
+			"chain_id",
+			"collector",
+			"reason"
+		],
+		registers: [registry]
+	});
 	const logEntriesTotal = new Counter({
 		name: LOG_ENTRIES_TOTAL_METRIC,
 		help: "Total indexer log entries by level.",
@@ -10603,6 +10774,17 @@ function create$15() {
 		],
 		registers: [registry]
 	});
+	const dbRowsCommittedTotal = new Counter({
+		name: DB_ROWS_COMMITTED_TOTAL_METRIC,
+		help: "Total database rows inserted, upserted, or deleted by collector commits.",
+		labelNames: [
+			"chain_id",
+			"collector",
+			"table",
+			"operation"
+		],
+		registers: [registry]
+	});
 	const entityCommitLastUnixtime = new Gauge({
 		name: ENTITY_COMMIT_LAST_UNIXTIME_METRIC,
 		help: "Unix timestamp in seconds for the last successful entity commit.",
@@ -10638,8 +10820,11 @@ function create$15() {
 					return;
 				case "runtime.log": {
 					const level = normalizeLogLevel(observation.level);
-					if (level === null) return;
-					logEntriesTotal.inc({ level }, 1);
+					if (level !== null && observation.emitted !== false) logEntriesTotal.inc({ level }, 1);
+					observeRuntimeLog({
+						observation,
+						logsDroppedTotal
+					});
 					return;
 				}
 				case "commit.applied":
@@ -10647,6 +10832,7 @@ function create$15() {
 						observation,
 						entitiesCommittedTotal,
 						entitiesAttemptedTotal,
+						dbRowsCommittedTotal,
 						entityCommitLastUnixtime,
 						collectorCommitLastUnixtime
 					});
@@ -10693,6 +10879,20 @@ function observeRuntimeEvent(parameters) {
 	if (headToDbInsertLatencyMs === null) return;
 	parameters.headToDbInsertLatencySeconds.observe(labels, sanitizeDurationSeconds(headToDbInsertLatencyMs / 1e3));
 }
+function observeRuntimeLog(parameters) {
+	const { observation } = parameters;
+	if (observation.event === void 0 || !droppedLogEvents.has(observation.event)) return;
+	const collector = normalizeLabelValue(observation.fields?.collector);
+	const reason = normalizeLabelValue(observation.fields?.reason);
+	if (collector === null || reason === null) return;
+	const count = parseNonNegativeInt(observation.fields?.count) ?? 1;
+	if (count <= 0) return;
+	parameters.logsDroppedTotal.inc({
+		chain_id: renderChainIdLabel(observation.chainId),
+		collector,
+		reason
+	}, count);
+}
 function observeCommitApplied(parameters) {
 	const { observation } = parameters;
 	const chainId = renderChainIdLabel(observation.chainId);
@@ -10726,6 +10926,19 @@ function observeCommitApplied(parameters) {
 			entity
 		}, committedAtUnixSeconds);
 	}
+	for (const dbRow of observation.dbRows) {
+		const collector = normalizeLabelValue(dbRow.collector);
+		const table = normalizeLabelValue(dbRow.table);
+		const operation = normalizeDbRowCommitOperation(dbRow.operation);
+		const count = parseNonNegativeInt(dbRow.count);
+		if (collector === null || table === null || operation === null || count === null || count <= 0) continue;
+		parameters.dbRowsCommittedTotal.inc({
+			chain_id: chainId,
+			collector,
+			table,
+			operation
+		}, count);
+	}
 }
 function shouldObserveHeadToDbInsertLatency(event) {
 	return !headToDbLatencyExcludedEvents.has(event);
@@ -10751,6 +10964,10 @@ function normalizeCommitOperation(operation) {
 	if (operation === "inserted" || operation === "upserted" || operation === "deleted" || operation === "ignored") return operation;
 	return null;
 }
+function normalizeDbRowCommitOperation(operation) {
+	if (operation === "inserted" || operation === "upserted" || operation === "deleted") return operation;
+	return null;
+}
 function normalizeLabelValue(value) {
 	if (typeof value !== "string") return null;
 	const candidate = value.trim();
@@ -10843,7 +11060,7 @@ function create$14(parameters) {
 						});
 					}
 				},
-				onCommitApplied: ({ collectors, stats, committedAtUnixMs }) => {
+				onCommitApplied: ({ collectors, stats, dbRows, committedAtUnixMs }) => {
 					if (sinks.length === 0) return;
 					try {
 						emitObservation(sinks, {
@@ -10851,6 +11068,7 @@ function create$14(parameters) {
 							chainId,
 							collectors,
 							stats,
+							dbRows,
 							committedAtUnixMs
 						});
 					} catch (error) {
@@ -10906,12 +11124,14 @@ function createObservedLogger(parameters) {
 	const wrap = (level, emit) => {
 		const enabled = isLogFnEnabled(emit);
 		return (entry) => {
-			if (enabled && isIndexerComponent(entry.component)) try {
+			if (isIndexerComponent(entry.component) && (enabled || isStructuredCollectorDropLog(entry))) try {
 				const chainId = parseChainId(entry.chain_id);
 				if (chainId !== null) parameters.onLogEntry({
 					type: "runtime.log",
 					chainId,
-					level
+					level,
+					...extractRuntimeLogMetadata(entry),
+					...enabled ? {} : { emitted: false }
 				});
 			} catch {}
 			emit(entry);
@@ -10926,6 +11146,18 @@ function createObservedLogger(parameters) {
 		fatal: wrap("fatal", parameters.logger.fatal)
 	};
 }
+function extractRuntimeLogMetadata(entry) {
+	const event = typeof entry.event === "string" ? entry.event : void 0;
+	const fields = Object.fromEntries(Object.entries(entry).filter(([key]) => key !== "msg" && key !== "component" && key !== "chain_id" && key !== "event"));
+	return {
+		...event === void 0 ? {} : { event },
+		...Object.keys(fields).length === 0 ? {} : { fields }
+	};
+}
+function isStructuredCollectorDropLog(entry) {
+	if (entry.event !== INDEXER_COLLECTOR_OFFER_TREE_DECODE_FAILED && entry.event !== INDEXER_COLLECTOR_OFFER_TREE_REJECTED && entry.event !== INDEXER_COLLECTOR_LOG_SKIPPED) return false;
+	return typeof entry.collector === "string" && typeof entry.reason === "string";
+}
 function emitObservation(sinks, observation) {
 	for (const sink of sinks) sink.observe(observation);
 }
@@ -10999,7 +11231,7 @@ async function getBook(params, db) {
 			levels_count: levels.length,
 			has_next_cursor: nextCursor != null,
 			first_level_tick: firstLevel?.tick ?? null,
-			first_level_obligation_units: firstLevel?.obligationUnits.toString() ?? null,
+			first_level_max_units: firstLevel?.maxUnits.toString() ?? null,
 			first_level_count: firstLevel?.count ?? null
 		});
 		return success({
@@ -11418,8 +11650,8 @@ async function getOffersQuery(db, parameters) {
             COALESCE(jsonb_agg(jsonb_build_object(
               'asset',  oc.asset,
               'oracle', oc.oracle_address,
-              'lltv',   oc.lltv,
-              'maxLif', oc.max_lif
+              'lltv',   oc.lltv::text,
+              'maxLif', oc.max_lif::text
             ) ORDER BY oc.asset), '[]'::jsonb) AS collaterals
       FROM ${obligationIdKeys} oia
       JOIN ${obligationCollateralsV2} oc
@@ -11436,7 +11668,7 @@ async function getOffersQuery(db, parameters) {
       mo.hash,
       mo.obligation_id,
       mo.group_maker,
-      mo.obligation_units,
+      mo.max_units,
       mo.consumed,
       mo.tick,
       mo.maturity,
@@ -11468,11 +11700,14 @@ async function getOffersQuery(db, parameters) {
     ORDER BY mo.hash ASC, mo.obligation_id ASC;
   `)).rows.map((row) => {
 		const receiverIfMakerIsSeller = (row.receiver_if_maker_is_seller ?? row.group_maker).toLowerCase();
+		const maxUnits = BigInt(row.max_units ?? 0);
+		const consumed = BigInt(row.consumed ?? 0);
+		const remainingUnits = maxUnits > consumed ? maxUnits - consumed : 0n;
 		return {
 			hash: row.hash,
 			obligationId: row.obligation_id,
 			maker: row.group_maker,
-			obligationUnits: BigInt(row.obligation_units ?? 0),
+			maxUnits,
 			tick: row.tick,
 			maturity: row.maturity,
 			expiry: row.expiry,
@@ -11487,7 +11722,7 @@ async function getOffersQuery(db, parameters) {
 				asset: c.asset,
 				oracle: c.oracle,
 				lltv: BigInt(c.lltv),
-				maxLif: BigInt(c.maxLif ?? 0)
+				maxLif: BigInt(c.maxLif)
 			})).sort((a, b) => a.asset.toLowerCase().localeCompare(b.asset.toLowerCase())),
 			callback: {
 				address: row.callback_address,
@@ -11495,9 +11730,9 @@ async function getOffersQuery(db, parameters) {
 			},
 			receiverIfMakerIsSeller,
 			exitOnly: row.exit_only,
-			consumed: BigInt(row.consumed ?? 0),
+			consumed,
 			available: BigInt(String(row.available ?? "0").split(".")[0] ?? "0"),
-			takeable: assetsToObligationUnits(BigInt(String(row.takeable ?? "0").split(".")[0] ?? "0"), row.tick),
+			takeable: assetsToUnits(BigInt(String(row.takeable ?? "0").split(".")[0] ?? "0"), row.tick, row.buy, remainingUnits),
 			blockNumber: row.block_number,
 			root: row.tree_root ? row.tree_root.toLowerCase() : void 0,
 			signature: row.root_signature ? row.root_signature.toLowerCase() : void 0,
@@ -11541,7 +11776,8 @@ async function getOffers(queryParameters, db) {
 			side: query.side,
 			obligationId: query.obligation_id,
 			cursor: query.cursor,
-			limit: query.limit
+			limit: query.limit,
+			requirePositiveTakeableAssets: true
 		});
 		logger.debug({
 			service: "api_controller",
@@ -11693,6 +11929,7 @@ function createApp$1(parameters) {
 		origin: "*",
 		exposeHeaders: ["x-request-id"]
 	}));
+	app.get("/", (c) => c.redirect("/docs"));
 	app.get("/v1/offers", async (c) => {
 		const { statusCode, body } = await services.getOffers(c.req.query());
 		return c.json(body, statusCode);
@@ -12117,6 +12354,10 @@ function* ask(operation) {
 
 //#endregion
 //#region src/indexer/engine/adapter/appliers/applyChainState.ts
+const emptyOutcome = () => ({
+	stats: [],
+	dbRows: []
+});
 function isChainUninitializedError$1(error) {
 	return error instanceof Error && error.message.includes("Chain state not initialized");
 }
@@ -12165,7 +12406,7 @@ const chainStateAppliers = {
 			context.chainMutationState.expectedTipHashForWrite = advanceParameters.tipHash;
 		}
 		context.chainMutationState.expectedChainState = nextChainState;
-		return [];
+		return emptyOutcome();
 	},
 	collector: async ({ mutation, dbTx, context }) => {
 		const collectorName = context.toCollectorName(mutation.name);
@@ -12179,7 +12420,7 @@ const chainStateAppliers = {
 			blockNumber: mutation.cursor,
 			epoch: BigInt(mutation.epoch)
 		});
-		return [];
+		return emptyOutcome();
 	}
 };
 
@@ -12192,33 +12433,66 @@ const LOTS_PENDING_LINK_TYPE = "offers_lots_missing_group";
 
 //#endregion
 //#region src/indexer/engine/adapter/appliers/applyMorphoV2.ts
+const outcome$3 = (parameters) => ({
+	stats: parameters.stats ?? [],
+	dbRows: parameters.dbRows ?? []
+});
 const morphoV2Appliers = {
 	transfers_create: async ({ mutation, dbTx }) => {
-		await dbTx.transfers.create(mutation.rows);
-		return mutation.rows.length > 0 ? [{
-			entity: "transfer",
-			operation: "inserted",
-			count: mutation.rows.length
-		}] : [];
+		const insertedTransfers = await dbTx.transfers.create(mutation.rows);
+		return outcome$3({
+			stats: mutation.rows.length > 0 ? [{
+				entity: "transfer",
+				operation: "inserted",
+				count: mutation.rows.length
+			}] : [],
+			dbRows: insertedTransfers > 0 ? [{
+				table: "transfers",
+				operation: "inserted",
+				count: insertedTransfers
+			}] : []
+		});
 	},
 	consumed_create: async ({ mutation, dbTx }) => {
-		await dbTx.consumed.create(mutation.rows);
-		return mutation.rows.length > 0 ? [{
-			entity: "consumed_event",
-			operation: "inserted",
-			count: mutation.rows.length
-		}] : [];
+		const inserted = await dbTx.consumed.create(mutation.rows);
+		return outcome$3({
+			stats: mutation.rows.length > 0 ? [{
+				entity: "consumed_event",
+				operation: "inserted",
+				count: mutation.rows.length
+			}] : [],
+			dbRows: [...inserted.groupsInserted > 0 ? [{
+				table: "groups",
+				operation: "inserted",
+				count: inserted.groupsInserted
+			}] : [], ...inserted.consumedEventsInserted > 0 ? [{
+				table: "consumed_events",
+				operation: "inserted",
+				count: inserted.consumedEventsInserted
+			}] : []]
+		});
 	},
 	seizures_record: async ({ mutation, dbTx, context }) => {
-		await context.pendingStore.applySeizureFacts({
+		const materialized = await context.pendingStore.applySeizureFacts({
 			dbTx,
 			seizureFacts: mutation.rows
 		});
-		return mutation.rows.length > 0 ? [{
-			entity: "seizure_fact",
-			operation: "inserted",
-			count: mutation.rows.length
-		}] : [];
+		return outcome$3({
+			stats: mutation.rows.length > 0 ? [{
+				entity: "seizure_fact",
+				operation: "inserted",
+				count: mutation.rows.length
+			}] : [],
+			dbRows: [...materialized.positionsUpserted > 0 ? [{
+				table: "positions",
+				operation: "upserted",
+				count: materialized.positionsUpserted
+			}] : [], ...materialized.transfersInserted > 0 ? [{
+				table: "transfers",
+				operation: "inserted",
+				count: materialized.transfersInserted
+			}] : []]
+		});
 	},
 	morpho_v2_rewind: async ({ mutation, dbTx, context }) => {
 		const deletedConsumedEvents = await dbTx.consumed.delete({
@@ -12242,17 +12516,35 @@ const morphoV2Appliers = {
 		});
 		const deletedTransfers = deletedDebtTransfers + deletedCollateralTransfers;
 		const stats = [];
-		if (deletedConsumedEvents > 0) stats.push({
-			entity: "consumed_event",
-			operation: "deleted",
-			count: deletedConsumedEvents
-		});
-		if (deletedTransfers > 0) stats.push({
-			entity: "transfer",
-			operation: "deleted",
-			count: deletedTransfers
+		const dbRows = [];
+		if (deletedConsumedEvents > 0) {
+			stats.push({
+				entity: "consumed_event",
+				operation: "deleted",
+				count: deletedConsumedEvents
+			});
+			dbRows.push({
+				table: "consumed_events",
+				operation: "deleted",
+				count: deletedConsumedEvents
+			});
+		}
+		if (deletedTransfers > 0) {
+			stats.push({
+				entity: "transfer",
+				operation: "deleted",
+				count: deletedTransfers
+			});
+			dbRows.push({
+				table: "transfers",
+				operation: "deleted",
+				count: deletedTransfers
+			});
+		}
+		return outcome$3({
+			stats,
+			dbRows
 		});
-		return stats;
 	}
 };
 
@@ -12263,7 +12555,12 @@ const buildGroupReferenceKey = (chainId, maker, group) => `${chainId}:${maker.to
 const buildCallbacksMissingOfferReference = (row) => `${row.offerHash.toLowerCase()}:${row.obligationId.toLowerCase()}`;
 const buildMerklePathMissingOfferReference = (row) => `${row.offerHash.toLowerCase()}:${row.obligationId.toLowerCase()}:${row.treeRoot.toLowerCase()}`;
 const buildLotMissingGroupReference = (row) => `${row.positionChainId}:${row.positionUser.toLowerCase()}:${row.group.toLowerCase()}:${row.obligationId.toLowerCase()}`;
-const stat = (parameters) => parameters.count > 0 ? [parameters] : [];
+const entityStat = (parameters) => parameters.count > 0 ? [parameters] : [];
+const dbRowStat = (parameters) => parameters.count > 0 ? [parameters] : [];
+const outcome$2 = (parameters) => ({
+	stats: parameters.stats ?? [],
+	dbRows: parameters.dbRows ?? []
+});
 async function selectExistingOfferKeys(parameters) {
 	const { context, dbTx, references } = parameters;
 	if (references.length === 0) return /* @__PURE__ */ new Set();
@@ -12344,45 +12641,93 @@ async function partitionLotsByGroupExistence(parameters) {
 }
 const offersAppliers = {
 	obligations_create: async ({ mutation, dbTx }) => {
-		await dbTx.obligations.create(mutation.rows);
-		return stat({
-			entity: "obligation",
-			operation: "inserted",
-			count: mutation.rows.length
+		const inserted = await dbTx.obligations.create(mutation.rows);
+		return outcome$2({
+			stats: entityStat({
+				entity: "obligation",
+				operation: "inserted",
+				count: mutation.rows.length
+			}),
+			dbRows: [
+				...dbRowStat({
+					table: "obligations",
+					operation: "inserted",
+					count: inserted.obligationsInserted
+				}),
+				...dbRowStat({
+					table: "obligation_id_keys",
+					operation: "inserted",
+					count: inserted.obligationIdKeysInserted
+				}),
+				...dbRowStat({
+					table: "obligation_collaterals_v2",
+					operation: "inserted",
+					count: inserted.obligationCollateralsInserted
+				})
+			]
 		});
 	},
 	groups_create: async ({ mutation, dbTx }) => {
-		await dbTx.groups.create(mutation.rows);
-		return stat({
-			entity: "group",
-			operation: "inserted",
-			count: mutation.rows.length
+		const insertedGroups = await dbTx.groups.create(mutation.rows);
+		return outcome$2({
+			stats: entityStat({
+				entity: "group",
+				operation: "inserted",
+				count: mutation.rows.length
+			}),
+			dbRows: dbRowStat({
+				table: "groups",
+				operation: "inserted",
+				count: insertedGroups
+			})
 		});
 	},
 	offers_create: async ({ mutation, dbTx }) => {
-		await dbTx.offers.create(mutation.batches);
-		return stat({
-			entity: "offer",
-			operation: "inserted",
-			count: mutation.batches.reduce((total, batch) => total + batch.offers.length, 0)
+		const insertedOffers = await dbTx.offers.create(mutation.batches);
+		return outcome$2({
+			stats: entityStat({
+				entity: "offer",
+				operation: "inserted",
+				count: insertedOffers.length
+			}),
+			dbRows: dbRowStat({
+				table: "offers",
+				operation: "inserted",
+				count: insertedOffers.length
+			})
 		});
 	},
 	offers_rewind: async ({ mutation, dbTx, context }) => {
-		return stat({
-			entity: "offer",
-			operation: "deleted",
-			count: await dbTx.offers.delete({
-				chainId: context.chainId,
-				blockNumberGte: mutation.blockNumberGte
+		const deletedOffers = await dbTx.offers.delete({
+			chainId: context.chainId,
+			blockNumberGte: mutation.blockNumberGte
+		});
+		return outcome$2({
+			stats: entityStat({
+				entity: "offer",
+				operation: "deleted",
+				count: deletedOffers
+			}),
+			dbRows: dbRowStat({
+				table: "offers",
+				operation: "deleted",
+				count: deletedOffers
 			})
 		});
 	},
 	trees_upsert: async ({ mutation, dbTx }) => {
-		await dbTx.trees.upsert(mutation.rows);
-		return stat({
-			entity: "tree",
-			operation: "upserted",
-			count: mutation.rows.length
+		const upsertedRoots = await dbTx.trees.upsert(mutation.rows);
+		return outcome$2({
+			stats: entityStat({
+				entity: "tree",
+				operation: "upserted",
+				count: mutation.rows.length
+			}),
+			dbRows: dbRowStat({
+				table: "trees",
+				operation: "upserted",
+				count: upsertedRoots.length
+			})
 		});
 	},
 	trees_upsert_paths: async ({ mutation, dbTx, context }) => {
@@ -12403,15 +12748,22 @@ const offersAppliers = {
 				blockNumber: context.pendingLinkReferenceBlockNumber()
 			}))
 		});
-		return [...stat({
-			entity: "tree_path",
-			operation: "upserted",
-			count: resolvableRows.length
-		}), ...stat({
-			entity: "tree_path",
-			operation: "ignored",
-			count: missingRows.length
-		})];
+		return outcome$2({
+			stats: [...entityStat({
+				entity: "tree_path",
+				operation: "upserted",
+				count: resolvableRows.length
+			}), ...entityStat({
+				entity: "tree_path",
+				operation: "ignored",
+				count: missingRows.length
+			})],
+			dbRows: dbRowStat({
+				table: "merkle_paths",
+				operation: "upserted",
+				count: resolvableRows.length
+			})
+		});
 	},
 	callbacks_upsert: async ({ mutation, dbTx, context }) => {
 		const { resolvableRows, missingRows } = await partitionCallbacksByOfferExistence({
@@ -12419,7 +12771,10 @@ const offersAppliers = {
 			dbTx,
 			rows: mutation.rows
 		});
-		if (resolvableRows.length > 0) await dbTx.callbacks.upsert(resolvableRows);
+		const inserted = resolvableRows.length > 0 ? await dbTx.callbacks.upsert(resolvableRows) : {
+			callbacksInserted: 0,
+			offersCallbacksInserted: 0
+		};
 		await context.pendingStore.recordIgnoredLinks({
 			dbTx,
 			records: missingRows.map((row) => ({
@@ -12431,22 +12786,36 @@ const offersAppliers = {
 				blockNumber: context.pendingLinkReferenceBlockNumber()
 			}))
 		});
-		return [...stat({
-			entity: "callback",
-			operation: "upserted",
-			count: resolvableRows.length
-		}), ...stat({
-			entity: "callback",
-			operation: "ignored",
-			count: missingRows.length
-		})];
+		return outcome$2({
+			stats: [...entityStat({
+				entity: "callback",
+				operation: "upserted",
+				count: resolvableRows.length
+			}), ...entityStat({
+				entity: "callback",
+				operation: "ignored",
+				count: missingRows.length
+			})],
+			dbRows: [...dbRowStat({
+				table: "callbacks",
+				operation: "inserted",
+				count: inserted.callbacksInserted
+			}), ...dbRowStat({
+				table: "offers_callbacks",
+				operation: "inserted",
+				count: inserted.offersCallbacksInserted
+			})]
+		});
 	},
 	lots_create: async ({ mutation, dbTx, context }) => {
 		const { resolvableRows, missingRows } = await partitionLotsByGroupExistence({
 			dbTx,
 			rows: mutation.rows
 		});
-		if (resolvableRows.length > 0) await dbTx.lots.create(resolvableRows);
+		const inserted = resolvableRows.length > 0 ? await dbTx.lots.create(resolvableRows) : {
+			lotsPositionsInserted: 0,
+			lotsInserted: 0
+		};
 		await context.pendingStore.recordIgnoredLinks({
 			dbTx,
 			records: missingRows.map((row) => ({
@@ -12458,43 +12827,76 @@ const offersAppliers = {
 				blockNumber: context.pendingLinkReferenceBlockNumber()
 			}))
 		});
-		return [...stat({
-			entity: "lot",
-			operation: "inserted",
-			count: resolvableRows.length
-		}), ...stat({
-			entity: "lot",
-			operation: "ignored",
-			count: missingRows.length
-		})];
+		return outcome$2({
+			stats: [...entityStat({
+				entity: "lot",
+				operation: "inserted",
+				count: resolvableRows.length
+			}), ...entityStat({
+				entity: "lot",
+				operation: "ignored",
+				count: missingRows.length
+			})],
+			dbRows: [...dbRowStat({
+				table: "lots_positions",
+				operation: "inserted",
+				count: inserted.lotsPositionsInserted
+			}), ...dbRowStat({
+				table: "lots",
+				operation: "inserted",
+				count: inserted.lotsInserted
+			})]
+		});
 	}
 };
 
 //#endregion
 //#region src/indexer/engine/adapter/appliers/applyOracle.ts
+const outcome$1 = (parameters) => ({
+	stats: parameters.stats ?? [],
+	dbRows: parameters.dbRows ?? []
+});
 const oracleApplier = { oracle: async ({ mutation, dbTx, context }) => {
-	await dbTx.oracles.upsert(mutation.rows.map((row) => ({
+	const upsertedOracles = await dbTx.oracles.upsert(mutation.rows.map((row) => ({
 		chainId: context.chainId,
 		...row,
 		address: row.address
 	})));
-	return mutation.rows.length > 0 ? [{
-		entity: "oracle",
-		operation: "upserted",
-		count: mutation.rows.length
-	}] : [];
+	return outcome$1({
+		stats: mutation.rows.length > 0 ? [{
+			entity: "oracle",
+			operation: "upserted",
+			count: mutation.rows.length
+		}] : [],
+		dbRows: upsertedOracles > 0 ? [{
+			table: "oracles",
+			operation: "upserted",
+			count: upsertedOracles
+		}] : []
+	});
 } };
 
 //#endregion
 //#region src/indexer/engine/adapter/appliers/applyPositions.ts
+const outcome = (parameters) => ({
+	stats: parameters.stats ?? [],
+	dbRows: parameters.dbRows ?? []
+});
 const positionsAppliers = {
 	positions_upsert: async ({ mutation, dbTx }) => {
-		await dbTx.positions.upsert(mutation.rows);
-		return mutation.rows.length > 0 ? [{
-			entity: "position",
-			operation: "upserted",
-			count: mutation.rows.length
-		}] : [];
+		const upsertedPositions = await dbTx.positions.upsert(mutation.rows);
+		return outcome({
+			stats: mutation.rows.length > 0 ? [{
+				entity: "position",
+				operation: "upserted",
+				count: mutation.rows.length
+			}] : [],
+			dbRows: upsertedPositions > 0 ? [{
+				table: "positions",
+				operation: "upserted",
+				count: upsertedPositions
+			}] : []
+		});
 	},
 	positions_rewind: async ({ mutation, dbTx, context }) => {
 		const deletedPositions = await dbTx.positions.setEmptyAfter({
@@ -12502,11 +12904,11 @@ const positionsAppliers = {
 			blockNumber: mutation.blockNumberGte,
 			type: Type.ERC20
 		});
-		return deletedPositions > 0 ? [{
+		return outcome({ stats: deletedPositions > 0 ? [{
 			entity: "position",
 			operation: "deleted",
 			count: deletedPositions
-		}] : [];
+		}] : [] });
 	}
 };
 
@@ -12819,7 +13221,9 @@ async function materializeSeizureFacts(parameters) {
 	if (seizureFacts.length === 0) return {
 		unresolvedFacts: [],
 		transfersCreate: [],
-		positionsUpsert: []
+		positionsUpsert: [],
+		transfersInserted: 0,
+		positionsUpserted: 0
 	};
 	const resolutionMap = await resolveCollateralAssetRefs({
 		dbTx,
@@ -12847,9 +13251,11 @@ async function materializeSeizureFacts(parameters) {
 		}));
 	}
 	const positionsUpsert = toCollateralPositionRows(resolvedTransfers);
+	let positionsUpserted = 0;
+	let transfersInserted = 0;
 	if (resolvedTransfers.length > 0) {
-		await dbTx.positions.upsert(positionsUpsert);
-		await dbTx.transfers.create(resolvedTransfers);
+		positionsUpserted = await dbTx.positions.upsert(positionsUpsert);
+		transfersInserted = await dbTx.transfers.create(resolvedTransfers);
 		await recomputeBackfilledCollateralBalances({
 			dbTx,
 			transfers: resolvedTransfers
@@ -12858,7 +13264,9 @@ async function materializeSeizureFacts(parameters) {
 	return {
 		unresolvedFacts,
 		transfersCreate: resolvedTransfers,
-		positionsUpsert
+		positionsUpsert,
+		transfersInserted,
+		positionsUpserted
 	};
 }
 const toFactsFromPendingRows = (chainId, rows) => rows.map((row) => ({
@@ -13108,15 +13516,20 @@ const createPendingLinkStore = (parameters) => {
 	const resolverTypes = resolverEntries.map((resolver) => resolver.type);
 	return {
 		applySeizureFacts: async ({ dbTx, seizureFacts }) => {
+			const materialized = await materializeSeizureFacts({
+				dbTx,
+				chainId,
+				seizureFacts
+			});
 			await recordUnresolvedSeizures({
 				dbTx,
 				chainId,
-				seizureFacts: (await materializeSeizureFacts({
-					dbTx,
-					chainId,
-					seizureFacts
-				})).unresolvedFacts
+				seizureFacts: materialized.unresolvedFacts
 			});
+			return {
+				positionsUpserted: materialized.positionsUpserted,
+				transfersInserted: materialized.transfersInserted
+			};
 		},
 		recordIgnoredLinks: async ({ dbTx, records }) => {
 			if (records.length === 0) return;
@@ -13465,6 +13878,7 @@ const create$11 = (parameters) => {
 			chainMutationState
 		};
 		const commitAppliedStats = [];
+		const commitAppliedDbRows = [];
 		const collectorsInCommit = /* @__PURE__ */ new Set();
 		const dispatchMutation = async (parameters) => {
 			const applier = mutationAppliers[parameters.mutation.t];
@@ -13477,18 +13891,24 @@ const create$11 = (parameters) => {
 		try {
 			await db.transaction(async (dbTx) => {
 				for (const mutation of tx.muts) {
-					const mutationApplyStats = await dispatchMutation({
+					const mutationApplyOutcome = await dispatchMutation({
 						mutation,
 						dbTx
 					});
 					if (mutation.collector === void 0) continue;
 					collectorsInCommit.add(mutation.collector);
-					for (const stat of mutationApplyStats) commitAppliedStats.push({
+					for (const stat of mutationApplyOutcome.stats) commitAppliedStats.push({
 						collector: mutation.collector,
 						entity: stat.entity,
 						operation: stat.operation,
 						count: stat.count
 					});
+					for (const dbRow of mutationApplyOutcome.dbRows) commitAppliedDbRows.push({
+						collector: mutation.collector,
+						table: dbRow.table,
+						operation: dbRow.operation,
+						count: dbRow.count
+					});
 				}
 			});
 		} catch (error) {
@@ -13503,6 +13923,7 @@ const create$11 = (parameters) => {
 			chainId,
 			collectors: [...collectorsInCommit],
 			stats: commitAppliedStats,
+			dbRows: commitAppliedDbRows,
 			onCommitApplied
 		});
 		const nowBlock = state.chain.checkpoints[state.chain.checkpoints.length - 1]?.n ?? 0;
@@ -13550,19 +13971,21 @@ const create$11 = (parameters) => {
 function emitCommitAppliedObservation(parameters) {
 	if (parameters.collectors.length === 0) return;
 	const aggregatedStats = aggregateCommitAppliedStats(parameters.stats);
+	const aggregatedDbRows = aggregateCommitAppliedDbRows(parameters.dbRows);
 	try {
 		parameters.onCommitApplied({
 			chainId: parameters.chainId,
 			collectors: parameters.collectors,
 			committedAtUnixMs: Date.now(),
-			stats: aggregatedStats
+			stats: aggregatedStats,
+			dbRows: aggregatedDbRows
 		});
 	} catch {}
 }
 function aggregateCommitAppliedStats(stats) {
 	const aggregatedByKey = /* @__PURE__ */ new Map();
 	for (const stat of stats) {
-		const count = normalizeMutationApplyStatCount(stat.count);
+		const count = normalizePositiveCount(stat.count);
 		if (count === null) continue;
 		const key = `${stat.collector}\u0000${stat.entity}\u0000${stat.operation}`;
 		const previous = aggregatedByKey.get(key);
@@ -13583,7 +14006,31 @@ function aggregateCommitAppliedStats(stats) {
 		return left.operation.localeCompare(right.operation);
 	});
 }
-function normalizeMutationApplyStatCount(value) {
+function aggregateCommitAppliedDbRows(dbRows) {
+	const aggregatedByKey = /* @__PURE__ */ new Map();
+	for (const dbRow of dbRows) {
+		const count = normalizePositiveCount(dbRow.count);
+		if (count === null) continue;
+		const key = `${dbRow.collector}\u0000${dbRow.table}\u0000${dbRow.operation}`;
+		const previous = aggregatedByKey.get(key);
+		if (previous === void 0) {
+			aggregatedByKey.set(key, {
+				collector: dbRow.collector,
+				table: dbRow.table,
+				operation: dbRow.operation,
+				count
+			});
+			continue;
+		}
+		previous.count += count;
+	}
+	return [...aggregatedByKey.values()].sort((left, right) => {
+		if (left.collector !== right.collector) return left.collector.localeCompare(right.collector);
+		if (left.table !== right.table) return left.table.localeCompare(right.table);
+		return left.operation.localeCompare(right.operation);
+	});
+}
+function normalizePositiveCount(value) {
 	if (!Number.isFinite(value)) return null;
 	const normalized = Math.trunc(value);
 	return normalized > 0 ? normalized : null;
@@ -13813,7 +14260,7 @@ function processConsumedLogs(parameters) {
 * A debt is modeled as a negative position: borrowing = transfer FROM user TO zeroAddress,
 * repayment = FROM zeroAddress TO user. The contract field is the obligationId.
 *
-* **Take event** — Every take is bilateral when obligationUnits > 0:
+* **Take event** — Every take is bilateral when units > 0:
 * - Buyer (maker if offerIsBuy, taker otherwise): debt decreases (repaid) → from: 0x0 → to: buyer
 * - Seller (taker if offerIsBuy, maker otherwise): debt increases (borrows) → from: seller → to: 0x0
 *
@@ -13845,14 +14292,14 @@ function processDebtTransfers(parameters) {
 		if (eventName === takeEvent.name) {
 			const args = rawLog.args;
 			const obligationId = args?.id_;
-			if (obligationId === void 0 || args?.maker === void 0 || args?.taker === void 0 || args?.offerIsBuy === void 0 || args?.obligationUnits === void 0) {
+			if (obligationId === void 0 || args?.maker === void 0 || args?.taker === void 0 || args?.offerIsBuy === void 0 || args?.units === void 0) {
 				logger.debug({
 					event: INDEXER_COLLECTOR_LOG_SKIPPED,
 					msg: "Skipping Take log because it is missing required args for debt"
 				});
 				continue;
 			}
-			if (args.obligationUnits === 0n) continue;
+			if (args.units === 0n) continue;
 			const buyer = args.offerIsBuy ? args.maker : args.taker;
 			const seller = args.offerIsBuy ? args.taker : args.maker;
 			const blockNumber = Number(rawLog.blockNumber);
@@ -13862,7 +14309,7 @@ function processDebtTransfers(parameters) {
 				contract: obligationId,
 				from: zeroAddress,
 				to: buyer,
-				value: args.obligationUnits,
+				value: args.units,
 				type: Type.DEBT_OF,
 				asset: zeroAddress,
 				blockNumber
@@ -13873,7 +14320,7 @@ function processDebtTransfers(parameters) {
 				contract: obligationId,
 				from: seller,
 				to: zeroAddress,
-				value: args.obligationUnits,
+				value: args.units,
 				type: Type.DEBT_OF,
 				asset: zeroAddress,
 				blockNumber
@@ -13883,21 +14330,21 @@ function processDebtTransfers(parameters) {
 		if (eventName === repayEvent.name) {
 			const args = rawLog.args;
 			const obligationId = args?.id_;
-			if (obligationId === void 0 || args?.obligationUnits === void 0 || args?.onBehalf === void 0) {
+			if (obligationId === void 0 || args?.units === void 0 || args?.onBehalf === void 0) {
 				logger.debug({
 					event: INDEXER_COLLECTOR_LOG_SKIPPED,
 					msg: "Skipping Repay log because it is missing required args"
 				});
 				continue;
 			}
-			if (args.obligationUnits === 0n) continue;
+			if (args.units === 0n) continue;
 			transfers.push(from$7({
 				id: `${baseId}-debt-repay`,
 				chainId,
 				contract: obligationId,
 				from: zeroAddress,
 				to: args.onBehalf,
-				value: args.obligationUnits,
+				value: args.units,
 				type: Type.DEBT_OF,
 				asset: zeroAddress,
 				blockNumber: Number(rawLog.blockNumber)
@@ -14221,6 +14668,15 @@ const processBatchesUntilCursorAdvance = async (stream, cursor, processBatch, op
 const collectorName$7 = "morpho_v2";
 const RESOLVE_CONSUMED_YIELD_EVERY_ITEMS = 256;
 const RESOLVE_CONSUMED_YIELD_EVERY_MS = 8;
+const MORPHO_DERIVED_LOG_ID_SUFFIXES = [
+	"-debt-buyer",
+	"-debt-seller",
+	"-debt-repay",
+	"-debt-liquidate",
+	"-collateral-supply",
+	"-collateral-withdraw",
+	"-collateral-liquidate"
+];
 const runNativeStep$2 = async (parameters) => {
 	const { request, client, db, logger } = parameters;
 	const consumedEvents = [];
@@ -14228,7 +14684,6 @@ const runNativeStep$2 = async (parameters) => {
 	const collateralTransfers = [];
 	const seizureFacts = [];
 	let logsIngestedCount = 0;
-	let logsIndexedCount = 0;
 	const streamStep = await processBatchesUntilCursorAdvance(streamLogs({
 		client,
 		contractAddress: client.chain.custom.morpho.address,
@@ -14253,7 +14708,13 @@ const runNativeStep$2 = async (parameters) => {
 			logs,
 			strict: false
 		});
-		logsIndexedCount += parsedLogs.length;
+		const untrackedLogsCount = logs.length - parsedLogs.length;
+		if (untrackedLogsCount > 0) logger.debug({
+			event: INDEXER_COLLECTOR_LOG_SKIPPED,
+			msg: "Skipping logs because they do not match tracked Morpho V2 events",
+			reason: "untracked_event",
+			count: untrackedLogsCount
+		});
 		consumedEvents.push(...processConsumedLogs({
 			logs: parsedLogs,
 			chainId: client.chain.id
@@ -14282,14 +14743,21 @@ const runNativeStep$2 = async (parameters) => {
 		logsIndexedCount: 0
 	};
 	const { nextCursor } = streamStep;
+	const resolvedConsumedEvents = await resolveConsumedEvents({
+		db,
+		consumedEvents,
+		logger
+	});
+	const logsIndexedCount = countIndexedMorphoLogs({
+		consumedEvents: resolvedConsumedEvents,
+		debtTransfers,
+		collateralTransfers,
+		seizureFacts
+	});
 	const domainMutations = buildDomainMutations$1({
 		debtTransfers,
 		collateralTransfers,
-		consumedEvents: await resolveConsumedEvents({
-			db,
-			consumedEvents,
-			logger
-		}),
+		consumedEvents: resolvedConsumedEvents,
 		seizureFacts
 	});
 	return {
@@ -14325,6 +14793,18 @@ const create$10 = (parameters) => {
 		});
 	};
 };
+function countIndexedMorphoLogs(parameters) {
+	const indexedLogIds = /* @__PURE__ */ new Set();
+	for (const consumedEvent of parameters.consumedEvents) indexedLogIds.add(consumedEvent.id);
+	for (const transfer of parameters.debtTransfers) indexedLogIds.add(stripMorphoDerivedLogIdSuffix(transfer.id));
+	for (const transfer of parameters.collateralTransfers) indexedLogIds.add(stripMorphoDerivedLogIdSuffix(transfer.id));
+	for (const seizureFact of parameters.seizureFacts) indexedLogIds.add(stripMorphoDerivedLogIdSuffix(seizureFact.id));
+	return indexedLogIds.size;
+}
+function stripMorphoDerivedLogIdSuffix(id) {
+	for (const suffix of MORPHO_DERIVED_LOG_ID_SUFFIXES) if (id.endsWith(suffix)) return id.slice(0, -suffix.length);
+	return id;
+}
 async function resolveConsumedEvents(parameters) {
 	const { db, consumedEvents, logger } = parameters;
 	if (consumedEvents.length === 0) return [];
@@ -14580,7 +15060,7 @@ const decodeCallbacks = (parameters) => {
 		if (!isEmptyCallback(offer)) continue;
 		if (offer.buy) {
 			const loanToken = offer.loanToken.toLowerCase();
-			const positionTypeId$1 = positionTypeId(Type.ERC20);
+			const positionTypeId$2 = positionTypeId(Type.ERC20);
 			positions.push(from$9({
 				chainId,
 				contract: loanToken,
@@ -14593,10 +15073,10 @@ const decodeCallbacks = (parameters) => {
 				positionChainId: chainId,
 				positionContract: loanToken,
 				positionUser: offer.maker,
-				positionTypeId: positionTypeId$1,
+				positionTypeId: positionTypeId$2,
 				group: offer.group,
 				obligationId,
-				size: obligationUnitsToAssets(offer.obligationUnits, offer.tick)
+				size: unitsToAssets(offer.maxUnits, offer.tick, offer.buy)
 			});
 			callbacks.push({
 				offerHash: hash$1(offer),
@@ -14605,22 +15085,22 @@ const decodeCallbacks = (parameters) => {
 					chainId,
 					contract: loanToken,
 					user: offer.maker,
-					positionTypeId: positionTypeId$1,
+					positionTypeId: positionTypeId$2,
 					type: CallbackType.Empty
 				}]
 			});
 			continue;
 		}
 		const contract = obligationId;
-		const positionTypeId$2 = positionTypeId(Type.COLLATERAL_OF);
+		const positionTypeId$1 = positionTypeId(Type.COLLATERAL_OF);
 		lots.push({
 			positionChainId: chainId,
 			positionContract: contract,
 			positionUser: offer.maker,
-			positionTypeId: positionTypeId$2,
+			positionTypeId: positionTypeId$1,
 			group: offer.group,
 			obligationId,
-			size: obligationUnitsToAssets(offer.obligationUnits, offer.tick)
+			size: unitsToAssets(offer.maxUnits, offer.tick, offer.buy)
 		});
 		callbacks.push({
 			offerHash: hash$1(offer),
@@ -14629,7 +15109,7 @@ const decodeCallbacks = (parameters) => {
 				chainId,
 				contract,
 				user: offer.maker,
-				positionTypeId: positionTypeId$2,
+				positionTypeId: positionTypeId$1,
 				type: CallbackType.Empty
 			}]
 		});
@@ -15269,9 +15749,11 @@ const runNativeStep = async (parameters) => {
 			});
 			transfers.push(...stepTransfers.transfers);
 			logsIndexedCount += stepTransfers.transfers.length;
-			for (let index = 0; index < stepTransfers.skippedInvalidLogs; index += 1) logger.debug({
+			if (stepTransfers.skippedInvalidLogs > 0) logger.debug({
 				event: INDEXER_COLLECTOR_LOG_SKIPPED,
-				msg: "Skipping log because it is missing required fields"
+				msg: "Skipping transfer logs because they are missing required fields",
+				reason: "missing_required_fields",
+				count: stepTransfers.skippedInvalidLogs
 			});
 			if (shouldContinueStream({
 				pendingPositionsCount: pendingNewPositions.length,
@@ -16674,7 +17156,7 @@ const init = (parameters) => {
 						maker: item.offer.maker,
 						group: item.offer.group,
 						tick: item.offer.tick,
-						assets: item.offer.obligationUnits.toString(),
+						max_units: item.offer.maxUnits.toString(),
 						buy: item.offer.buy
 					});
 				}
@@ -17997,7 +18479,7 @@ function buildOfferAssociationsFromOffers(parameters) {
 			user: offer.maker,
 			type: Type.ERC20,
 			asset: loanToken,
-			balance: obligationUnitsToAssets(offer.obligationUnits, offer.tick),
+			balance: unitsToAssets(offer.maxUnits, offer.tick, true),
 			blockNumber
 		}));
 		callbacks.push({
@@ -18018,7 +18500,7 @@ function buildOfferAssociationsFromOffers(parameters) {
 			positionTypeId: erc20TypeId,
 			group: offer.group,
 			obligationId,
-			size: obligationUnitsToAssets(offer.obligationUnits, offer.tick)
+			size: unitsToAssets(offer.maxUnits, offer.tick, offer.buy)
 		});
 	}
 	return {
@@ -18146,7 +18628,8 @@ function createMockOffers(parameters) {
 		const collaterals = collateralSelections.map((asset) => from$13({
 			asset,
 			oracle: allowedOracles[int(allowedOracles.length)],
-			lltv
+			lltv,
+			maxLif: 0n
 		}));
 		if (!chainRegistry.getById(chain.id)) throw new Error(`Missing chain config for id ${chain.id}`);
 		return {