@morpho-dev/router 0.11.0 → 0.12.1

package/dist/index.browser.mjs

@@ -8,10 +8,10 @@ import createOpenApiFetchClient from "openapi-fetch";
 import { bytesToHex, concatHex, decodeAbiParameters, encodeAbiParameters, getAddress, hashTypedData, hexToBytes, isAddress, isHex, keccak256, maxUint256, numberToHex, pad, parseAbi, publicActions, recoverAddress, zeroAddress } from "viem";
 import { getBlockNumber, getLogs, multicall } from "viem/actions";
 import { anvil, base, mainnet } from "viem/chains";
-import { StandardMerkleTree } from "@openzeppelin/merkle-tree";
-import { gzip, ungzip } from "pako";
+import { SimpleMerkleTree } from "@openzeppelin/merkle-tree";
+import { Inflate, gzip } from "pako";
 import { context, propagation } from "@opentelemetry/api";
-import "drizzle-orm";
+import { sql } from "drizzle-orm";
 import { bigint, boolean, foreignKey, index, integer, numeric, pgSchema, primaryKey, serial, text, timestamp, uniqueIndex, varchar } from "drizzle-orm/pg-core";
 
 //#region src/utils/Errors.ts
@@ -77,8 +77,10 @@ var Tick_exports = /* @__PURE__ */ __exportAll({
 	InvalidTickError: () => InvalidTickError,
 	MAX_PRICE: () => MAX_PRICE,
 	TICK_RANGE: () => TICK_RANGE,
+	assetsToUnits: () => assetsToUnits,
 	priceToTick: () => priceToTick,
-	tickToPrice: () => tickToPrice
+	tickToPrice: () => tickToPrice,
+	unitsToAssets: () => unitsToAssets
 });
 /** ln(1 + 0.025), scaled by 1e18. Matches TickLib onchain constant. */
 const LN_ONE_PLUS_DELTA = 24692612590371501n;
@@ -136,6 +138,81 @@ function assertTick(tick) {
 function assertPrice(price) {
 	if (price < 0n || price > MAX_PRICE) throw new InvalidPriceError(price);
 }
+/**
+* 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.
+* @param buy - Whether the maker side of the offer is buy (`true`) or sell (`false`).
+* @returns The equivalent amount in maker-side assets.
+*/
+function unitsToAssets(units, tick, buy) {
+	const price = tickToPrice(tick);
+	return buy ? unitsToFloorAssets(units, price) : unitsToCeilAssets(units, price);
+}
+/**
+* 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.
+* @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 assetsToUnits(assets, tick, buy, remainingUnits) {
+	if (remainingUnits <= 0n) return 0n;
+	if (assets < 0n) return 0n;
+	const price = tickToPrice(tick);
+	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";
 	constructor(tick) {
@@ -157,7 +234,7 @@ function from$15(level) {
 	return {
 		tick: level.tick,
 		price: price.toString(),
-		assets: level.assets.toString(),
+		max_units: level.maxUnits.toString(),
 		count: level.count
 	};
 }
@@ -215,9 +292,11 @@ function from$14(obligation, quote, chainId) {
 		collaterals: obligation.collaterals.map((c) => ({
 			token: c.asset,
 			lltv: c.lltv.toString(),
+			max_lif: c.maxLif.toString(),
 			oracle: c.oracle
 		})),
 		maturity: obligation.maturity,
+		rcf_threshold: obligation.rcfThreshold.toString(),
 		ask: {
 			tick: quote.ask.tick,
 			price: quote.ask.price.toString()
@@ -258,15 +337,15 @@ function from$13(input) {
 				collaterals: input.collaterals.map((c) => ({
 					token: c.asset,
 					lltv: c.lltv.toString(),
+					max_lif: c.maxLif.toString(),
 					oracle: c.oracle
 				})),
-				maturity: input.maturity
+				maturity: input.maturity,
+				rcf_threshold: input.rcfThreshold.toString()
 			},
 			buy: input.buy,
 			maker: input.maker,
-			assets: input.assets.toString(),
-			obligation_units: input.obligationUnits.toString(),
-			obligation_shares: input.obligationShares.toString(),
+			max_units: input.maxUnits.toString(),
 			start: input.start,
 			expiry: input.expiry,
 			tick: input.tick,
@@ -274,7 +353,8 @@ function from$13(input) {
 			session: input.session,
 			callback: input.callback.address,
 			callback_data: input.callback.data,
-			receiver_if_maker_is_seller: input.receiverIfMakerIsSeller
+			receiver_if_maker_is_seller: input.receiverIfMakerIsSeller,
+			exit_only: input.exitOnly
 		},
 		offer_hash: input.hash,
 		obligation_id: input.obligationId,
@@ -327,15 +407,15 @@ const offerExample = {
 			collaterals: [{
 				token: "0x34Cf890dB685FC536E05652FB41f02090c3fb751",
 				lltv: "860000000000000000",
+				max_lif: "0",
 				oracle: "0x45093658BE7f90B63D7c359e8f408e503c2D9401"
 			}],
-			maturity: 1761922799
+			maturity: 1761922799,
+			rcf_threshold: "0"
 		},
 		buy: false,
 		maker: "0x7b093658BE7f90B63D7c359e8f408e503c2D9401",
-		assets: "369216000000000000000000",
-		obligation_units: "0",
-		obligation_shares: "0",
+		max_units: "369216000000000000000000",
 		start: 1761922790,
 		expiry: 1761922799,
 		tick: 495,
@@ -343,7 +423,8 @@ const offerExample = {
 		session: "0x0000000000000000000000000000000000000000000000000000000000000000",
 		callback: "0x0000000000000000000000000000000000000000",
 		callback_data: "0x",
-		receiver_if_maker_is_seller: "0x7b093658BE7f90B63D7c359e8f408e503c2D9401"
+		receiver_if_maker_is_seller: "0x7b093658BE7f90B63D7c359e8f408e503c2D9401",
+		exit_only: false
 	},
 	offer_hash: "0xac4bd8318ec914f89f8af913f162230575b0ac0696a19256bc12138c5cfe1427",
 	obligation_id: "0x25690ae1aee324a005be565f3bcdd16dbf8daf79",
@@ -377,11 +458,10 @@ const missingCollectorExample = {
 };
 const validateOfferExample = {
 	maker: "0x7b093658BE7f90B63D7c359e8f408e503c2D9401",
-	assets: "369216000000000000000000",
-	obligation_units: "0",
-	obligation_shares: "0",
+	max_units: "369216000000000000000000",
 	tick: 495,
 	maturity: 1761922799,
+	rcf_threshold: "0",
 	expiry: 1761922799,
 	start: 1761922790,
 	group: "0x000000000000000000000000000000000000000000000000000000000008b8f4",
@@ -392,13 +472,15 @@ const validateOfferExample = {
 	collaterals: [{
 		asset: "0x34Cf890dB685FC536E05652FB41f02090c3fb751",
 		oracle: "0x45093658BE7f90B63D7c359e8f408e503c2D9401",
-		lltv: "860000000000000000"
+		lltv: "860000000000000000",
+		max_lif: "0"
 	}],
 	callback: {
 		address: "0x0000000000000000000000000000000000000000",
 		data: "0x"
 	},
-	receiver_if_maker_is_seller: "0x7b093658BE7f90B63D7c359e8f408e503c2D9401"
+	receiver_if_maker_is_seller: "0x7b093658BE7f90B63D7c359e8f408e503c2D9401",
+	exit_only: false
 };
 const routerStatusExample = {
 	status: "live",
@@ -442,6 +524,10 @@ __decorate([ApiProperty({
 	type: "string",
 	example: "860000000000000000"
 })], CollateralResponse.prototype, "lltv", void 0);
+__decorate([ApiProperty({
+	type: "string",
+	example: "0"
+})], CollateralResponse.prototype, "max_lif", void 0);
 __decorate([ApiProperty({
 	type: "string",
 	example: "0x45093658BE7f90B63D7c359e8f408e503c2D9401"
@@ -459,6 +545,10 @@ __decorate([ApiProperty({
 	type: "string",
 	example: validateOfferExample.collaterals[0].lltv
 })], ValidateCollateralRequest.prototype, "lltv", void 0);
+__decorate([ApiProperty({
+	type: "string",
+	example: validateOfferExample.collaterals[0].max_lif
+})], ValidateCollateralRequest.prototype, "max_lif", void 0);
 var ValidateCallbackRequest = class {};
 __decorate([ApiProperty({
 	type: "string",
@@ -503,6 +593,10 @@ __decorate([ApiProperty({
 	type: "number",
 	example: offerExample.offer.obligation.maturity
 })], ObligationOfferResponse.prototype, "maturity", void 0);
+__decorate([ApiProperty({
+	type: "string",
+	example: offerExample.offer.obligation.rcf_threshold
+})], ObligationOfferResponse.prototype, "rcf_threshold", void 0);
 var OfferDataResponse = class {};
 __decorate([ApiProperty({
 	type: () => ObligationOfferResponse,
@@ -518,16 +612,8 @@ __decorate([ApiProperty({
 })], OfferDataResponse.prototype, "maker", void 0);
 __decorate([ApiProperty({
 	type: "string",
-	example: offerExample.offer.assets
-})], OfferDataResponse.prototype, "assets", void 0);
-__decorate([ApiProperty({
-	type: "string",
-	example: offerExample.offer.obligation_units
-})], OfferDataResponse.prototype, "obligation_units", void 0);
-__decorate([ApiProperty({
-	type: "string",
-	example: offerExample.offer.obligation_shares
-})], OfferDataResponse.prototype, "obligation_shares", void 0);
+	example: offerExample.offer.max_units
+})], OfferDataResponse.prototype, "max_units", void 0);
 __decorate([ApiProperty({
 	type: "number",
 	example: offerExample.offer.start
@@ -562,6 +648,10 @@ __decorate([ApiProperty({
 	type: "string",
 	example: offerExample.offer.receiver_if_maker_is_seller
 })], OfferDataResponse.prototype, "receiver_if_maker_is_seller", void 0);
+__decorate([ApiProperty({
+	type: "boolean",
+	example: offerExample.offer.exit_only
+})], OfferDataResponse.prototype, "exit_only", void 0);
 var OfferListItemResponse = class {};
 __decorate([ApiProperty({
 	type: () => OfferDataResponse,
@@ -624,6 +714,10 @@ __decorate([ApiProperty({
 	type: "number",
 	example: 1761922800
 })], ObligationResponse.prototype, "maturity", void 0);
+__decorate([ApiProperty({
+	type: "string",
+	example: "0"
+})], ObligationResponse.prototype, "rcf_threshold", void 0);
 __decorate([ApiProperty({ type: () => AskResponse })], ObligationResponse.prototype, "ask", void 0);
 __decorate([ApiProperty({ type: () => BidResponse })], ObligationResponse.prototype, "bid", void 0);
 var ObligationListResponse = class extends SuccessResponse {};
@@ -773,18 +867,9 @@ __decorate([ApiProperty({
 })], ValidateOfferRequest.prototype, "maker", void 0);
 __decorate([ApiProperty({
 	type: "string",
-	example: validateOfferExample.assets
-})], ValidateOfferRequest.prototype, "assets", void 0);
-__decorate([ApiProperty({
-	type: "string",
-	example: validateOfferExample.obligation_units,
-	required: false
-})], ValidateOfferRequest.prototype, "obligation_units", void 0);
-__decorate([ApiProperty({
-	type: "string",
-	example: validateOfferExample.obligation_shares,
+	example: validateOfferExample.max_units,
 	required: false
-})], ValidateOfferRequest.prototype, "obligation_shares", void 0);
+})], ValidateOfferRequest.prototype, "max_units", void 0);
 __decorate([ApiProperty({
 	type: "number",
 	example: validateOfferExample.tick,
@@ -795,6 +880,10 @@ __decorate([ApiProperty({
 	type: "number",
 	example: validateOfferExample.maturity
 })], ValidateOfferRequest.prototype, "maturity", void 0);
+__decorate([ApiProperty({
+	type: "string",
+	example: validateOfferExample.rcf_threshold
+})], ValidateOfferRequest.prototype, "rcf_threshold", void 0);
 __decorate([ApiProperty({
 	type: "number",
 	example: validateOfferExample.expiry
@@ -831,6 +920,11 @@ __decorate([ApiProperty({
 	type: "string",
 	example: validateOfferExample.receiver_if_maker_is_seller
 })], ValidateOfferRequest.prototype, "receiver_if_maker_is_seller", void 0);
+__decorate([ApiProperty({
+	type: "boolean",
+	example: false,
+	required: false
+})], ValidateOfferRequest.prototype, "exit_only", void 0);
 var ValidateOffersRequest = class {};
 __decorate([ApiProperty({
 	type: "number",
@@ -909,7 +1003,7 @@ __decorate([ApiProperty({
 __decorate([ApiProperty({
 	type: "string",
 	example: "369216000000000000000000"
-})], BookLevelResponse.prototype, "assets", void 0);
+})], BookLevelResponse.prototype, "max_units", void 0);
 __decorate([ApiProperty({
 	type: "number",
 	example: 5
@@ -918,7 +1012,7 @@ const positionExample = {
 	chain_id: 1,
 	contract: "0xC9A9C45C0eB717f8b5F193Af6bAa05A1c0Ac5078",
 	user: "0x7b093658BE7f90B63D7c359e8f408e503c2D9401",
-	obligation_id: "0x12590ae1aee324a005be565f3bcdd16dbf8daf79",
+	obligation_id: "0x12590ae1aee324a005be565f3bcdd16dbf8daf7969b26c181c8b8f467dad9f67",
 	reserved: "200000000000000000000",
 	block_number: 21345678
 };
@@ -1533,7 +1627,7 @@ const OpenApi = async () => {
 			info: {
 				title: "Router API",
 				version: "1.0.0",
-				description: "API for the Morpho Router"
+				description: process.env.COMMIT_SHA ? `API for the Morpho Router — version: ${process.env.COMMIT_SHA.slice(0, 7)}` : "API for the Morpho Router"
 			},
 			servers: [{
 				url: "https://router.morpho.dev",
@@ -1604,7 +1698,7 @@ function isValidOfferHashCursor(val) {
 	return /^0x[a-f0-9]{64}$/i.test(val);
 }
 function isValidObligationIdCursor(val) {
-	return /^0x[a-f0-9]{40}$/i.test(val);
+	return /^0x[a-f0-9]{64}$/i.test(val);
 }
 function isValidOfferCursor(val) {
 	const [hash, obligationId, ...rest] = val.split(":");
@@ -1686,9 +1780,9 @@ const GetOffersQueryParams = PaginationQueryParams.omit({ cursor: true }).extend
 		description: "Side of the offer. Required when using obligation_id.",
 		example: "buy"
 	}),
-	obligation_id: z$1.string().regex(/^0x[a-fA-F0-9]{40}$/, { error: "Obligation id must be a valid 20-byte hex string" }).transform((val) => val.toLowerCase()).optional().meta({
+	obligation_id: z$1.string().regex(/^0x[a-fA-F0-9]{64}$/, { error: "Obligation id must be a valid 32-byte hex string" }).transform((val) => val.toLowerCase()).optional().meta({
 		description: "Offers obligation id. Required when not using maker.",
-		example: "0x1234567890123456789012345678901234567890"
+		example: "0x1234567890123456789012345678901234567890123456789012345678901234"
 	}),
 	maker: z$1.string().regex(/^0x[a-fA-F0-9]{40}$/, { error: "Maker must be a valid 20-byte address" }).transform((val) => val.toLowerCase()).optional().meta({
 		description: "Maker address to filter offers by. Alternative to obligation_id + side.",
@@ -1773,9 +1867,9 @@ const GetObligationsQueryParams = z$1.object({
 		example: "-ask,bid,maturity"
 	})
 });
-const GetObligationParams = z$1.object({ obligation_id: z$1.string({ error: "Obligation id is required and must be a valid 20-byte hex string" }).regex(/^0x[a-fA-F0-9]{40}$/, { error: "Obligation id must be a valid 20-byte hex string" }).transform((val) => val.toLowerCase()).meta({
+const GetObligationParams = z$1.object({ obligation_id: z$1.string({ error: "Obligation id is required and must be a valid 32-byte hex string" }).regex(/^0x[a-fA-F0-9]{64}$/, { error: "Obligation id must be a valid 32-byte hex string" }).transform((val) => val.toLowerCase()).meta({
 	description: "Obligation id",
-	example: "0x1234567890123456789012345678901234567890"
+	example: "0x1234567890123456789012345678901234567890123456789012345678901234"
 }) });
 /** Validate a book cursor format: {side, lastTick, offersCursor} */
 function isValidBookCursor(cursorString) {
@@ -1810,9 +1904,9 @@ const HealthQueryParams = z$1.object({ strict: z$1.enum([
 }) });
 const GetBookParams = z$1.object({
 	...BookPaginationQueryParams.shape,
-	obligation_id: z$1.string({ error: "Obligation id is required and must be a valid 20-byte hex string" }).regex(/^0x[a-fA-F0-9]{40}$/, { error: "Obligation id must be a valid 20-byte hex string" }).transform((val) => val.toLowerCase()).meta({
+	obligation_id: z$1.string({ error: "Obligation id is required and must be a valid 32-byte hex string" }).regex(/^0x[a-fA-F0-9]{64}$/, { error: "Obligation id must be a valid 32-byte hex string" }).transform((val) => val.toLowerCase()).meta({
 		description: "Obligation id",
-		example: "0x1234567890123456789012345678901234567890"
+		example: "0x1234567890123456789012345678901234567890123456789012345678901234"
 	}),
 	side: z$1.enum(["buy", "sell"]).meta({
 		description: "Side of the book (buy or sell).",
@@ -1900,57 +1994,75 @@ const MetaMorphoFactory = parseAbi(["event CreateMetaMorpho(address indexed meta
 //#region src/core/Abi/MorphoV2.ts
 const MorphoV2 = parseAbi([
 	"constructor()",
-	"function collateralOf(bytes20 id, address user, uint256 collateralIndex) view returns (uint128)",
-	"function consume(bytes32 group, uint256 amount)",
+	"function activatedCollaterals(bytes32 id, address user) view returns (uint128)",
+	"function collateralOf(bytes32 id, address user, uint256 index) view returns (uint128)",
 	"function consumed(address user, bytes32 group) view returns (uint256)",
-	"function debtOf(bytes20 id, address user) view returns (uint256)",
-	"function defaultFees(address loanToken, uint256 index) view returns (uint16)",
+	"function creditAfterSlashing(bytes32 id, address user) view returns (uint256)",
+	"function creditOf(bytes32 id, address user) view returns (uint256)",
+	"function debtOf(bytes32 id, address user) view returns (uint256)",
+	"function defaultFees(address loanToken, uint256) view returns (uint16)",
 	"function feeSetter() view returns (address)",
-	"function fees(bytes20 id) view returns (uint16[6])",
+	"function fees(bytes32 id) view returns (uint16[7])",
 	"function flashLoan(address token, uint256 assets, address callback, bytes data)",
-	"function isHealthy((address loanToken, (address token, uint256 lltv, address oracle)[] collaterals, uint256 maturity, uint256 minCollatValue) obligation, bytes20 id, address borrower) view returns (bool)",
-	"function liquidate((address loanToken, (address token, uint256 lltv, address oracle)[] collaterals, uint256 maturity, uint256 minCollatValue) obligation, uint256 collateralIndex, uint256 seizedAssets, uint256 repaidUnits, address borrower, bytes data) returns (uint256, uint256)",
+	"function isAuthorized(address authorizer, address authorized) view returns (bool)",
+	"function isHealthy((address loanToken, (address token, uint256 lltv, uint256 maxLif, address oracle)[] collaterals, uint256 maturity, uint256 rcfThreshold) obligation, bytes32 id, address borrower) view returns (bool)",
+	"function liquidate((address loanToken, (address token, uint256 lltv, uint256 maxLif, address oracle)[] collaterals, uint256 maturity, uint256 rcfThreshold) obligation, uint256 collateralIndex, uint256 seizedAssets, uint256 repaidUnits, address borrower, bytes data) returns (uint256, uint256)",
+	"function maxCollateralPerUser(address collateralToken) view returns (uint256)",
+	"function maxLif(uint256 lltv, uint256 cursor) pure returns (uint256)",
+	"function maxTakeableAssets(address loanToken) view returns (uint256)",
+	"function maxTotalUnits(address loanToken) view returns (uint128)",
+	"function maxTradingFee(uint256 index) pure returns (uint256)",
 	"function multicall(bytes[] calls)",
-	"function obligationCreated(bytes20 id) view returns (bool)",
-	"function obligationState(bytes20 id) view returns (uint128 totalUnits, uint128 totalShares, uint256 withdrawable, bool created, uint16[6] fees)",
+	"function 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, address oracle)[] collaterals, uint256 maturity, uint256 minCollatValue) 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)",
 	"function setFeeSetter(address newFeeSetter)",
-	"function setObligationTradingFee(bytes20 id, uint256 index, uint256 newTradingFee)",
+	"function setIsAuthorized(address onBehalf, address authorized, bool newIsAuthorized)",
+	"function setMaxCollateralPerUser(address collateralToken, uint256 newMaxCollateralPerUser)",
+	"function setMaxTakeableAssets(address loanToken, uint256 newMaxTakeableAssets)",
+	"function setMaxTotalUnits(address loanToken, uint128 newMaxTotalUnits)",
+	"function setObligationTradingFee(bytes32 id, uint256 index, uint256 newTradingFee)",
 	"function setOwner(address newOwner)",
 	"function setTradingFeeRecipient(address feeRecipient)",
-	"function sharesOf(bytes20 id, address user) view returns (uint256)",
-	"function shuffleSession()",
-	"function supplyCollateral((address loanToken, (address token, uint256 lltv, address oracle)[] collaterals, uint256 maturity, uint256 minCollatValue) obligation, uint256 collateralIndex, uint256 assets, address onBehalf)",
-	"function take(uint256 buyerAssets, uint256 sellerAssets, uint256 obligationUnits, uint256 obligationShares, address taker, address takerCallback, bytes takerCallbackData, address receiverIfTakerIsSeller, ((address loanToken, (address token, uint256 lltv, address oracle)[] collaterals, uint256 maturity, uint256 minCollatValue) obligation, bool buy, address maker, uint256 assets, uint256 obligationUnits, uint256 obligationShares, uint256 start, uint256 expiry, uint256 tick, bytes32 group, bytes32 session, address callback, bytes callbackData, address receiverIfMakerIsSeller) offer, (uint8 v, bytes32 r, bytes32 s) sig, bytes32 root, bytes32[] proof) returns (uint256, uint256, uint256, uint256)",
-	"function toId((address loanToken, (address token, uint256 lltv, address oracle)[] collaterals, uint256 maturity, uint256 minCollatValue) obligation) view returns (bytes20)",
-	"function toObligation(bytes20 id) view returns ((address loanToken, (address token, uint256 lltv, address oracle)[] collaterals, uint256 maturity, uint256 minCollatValue))",
-	"function totalShares(bytes20 id) view returns (uint256)",
-	"function totalUnits(bytes20 id) view returns (uint256)",
-	"function touchObligation((address loanToken, (address token, uint256 lltv, address oracle)[] collaterals, uint256 maturity, uint256 minCollatValue) obligation) returns (bytes20)",
-	"function tradingFee(bytes20 id, uint256 timeToMaturity) view returns (uint256)",
+	"function 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 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)",
+	"function touchObligation((address loanToken, (address token, uint256 lltv, uint256 maxLif, address oracle)[] collaterals, uint256 maturity, uint256 rcfThreshold) obligation) returns (bytes32)",
+	"function tradingFee(bytes32 id, uint256 timeToMaturity) view returns (uint256)",
 	"function tradingFeeRecipient() view returns (address)",
-	"function withdraw((address loanToken, (address token, uint256 lltv, address oracle)[] collaterals, uint256 maturity, uint256 minCollatValue) obligation, uint256 obligationUnits, uint256 shares, address onBehalf, address receiver) returns (uint256, uint256)",
-	"function withdrawCollateral((address loanToken, (address token, uint256 lltv, address oracle)[] collaterals, uint256 maturity, uint256 minCollatValue) obligation, uint256 collateralIndex, uint256 assets, address onBehalf, address receiver)",
-	"function withdrawable(bytes20 id) view returns (uint256)",
+	"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 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 Consume(address indexed user, bytes32 indexed group, uint256 amount)",
 	"event FlashLoan(address indexed caller, address indexed token, uint256 assets)",
-	"event Liquidate(address indexed caller, bytes20 indexed id_, uint256 collateralIndex, uint256 seizedAssets, uint256 repaidUnits, address indexed borrower, uint256 badDebt)",
-	"event ObligationCreated(bytes20 indexed id_, (address loanToken, (address token, uint256 lltv, address oracle)[] collaterals, uint256 maturity, uint256 minCollatValue) obligation)",
-	"event Repay(address indexed caller, bytes20 indexed id_, uint256 obligationUnits, address indexed onBehalf)",
+	"event 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 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)",
-	"event SetObligationTradingFee(bytes20 indexed id_, uint256 indexed index, uint256 newTradingFee)",
+	"event SetIsAuthorized(address indexed caller, address indexed onBehalf, address indexed authorized, bool newIsAuthorized)",
+	"event SetMaxCollateralPerUser(address indexed collateralToken, uint256 maxCollateralPerUser)",
+	"event SetMaxTakeableAssets(address indexed loanToken, uint256 maxTakeableAssets)",
+	"event SetMaxTotalUnits(address indexed loanToken, uint128 maxTotalUnits)",
+	"event SetObligationTradingFee(bytes32 indexed id_, uint256 indexed index, uint256 newTradingFee)",
 	"event SetOwner(address indexed owner)",
 	"event SetTradingFeeRecipient(address indexed feeRecipient)",
-	"event ShuffleSession(address indexed user, bytes32 session)",
-	"event SupplyCollateral(address caller, bytes20 indexed id_, address indexed collateral, uint256 assets, address indexed onBehalf)",
-	"event Take(address caller, bytes20 indexed id_, address indexed maker, address indexed taker, bool offerIsBuy, uint256 buyerAssets, uint256 sellerAssets, uint256 obligationUnits, uint256 obligationShares, bool buyerIsLender, bool sellerIsBorrower, address sellerReceiver, bytes32 group, uint256 consumed)",
-	"event Withdraw(address caller, bytes20 indexed id_, uint256 obligationUnits, uint256 shares, address indexed onBehalf, address indexed receiver)",
-	"event WithdrawCollateral(address caller, bytes20 indexed id_, address indexed collateral, uint256 assets, address indexed onBehalf, address receiver)"
+	"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 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)"
 ]);
 
 //#endregion
@@ -2243,8 +2355,8 @@ const chains$1 = {
 		name: "base",
 		custom: {
 			morpho: {
-				address: "0x4C752Cdc4b13c9A6a933CbecfE050eC0BA0B45f9",
-				blockCreated: 42365274
+				address: "0x26378861d9c740fe86e7472752aef5b1a783c60b",
+				blockCreated: 43606117
 			},
 			morphoBlue: {
 				address: "0xBBBBBbbBBb9cC5e90e3b3Af64bdAF62C37EEFFCb",
@@ -2273,8 +2385,8 @@ const chains$1 = {
 		name: "ethereum-virtual-testnet",
 		custom: {
 			morpho: {
-				address: "0x9ac49a344376964291f7289663beb78e2952de44",
-				blockCreated: 23229385
+				address: "0x94c576ee728ee290116ee65c0d1e9fed4a1b5041",
+				blockCreated: 23244323
 			},
 			morphoBlue: {
 				address: "0xBBBBBbbBBb9cC5e90e3b3Af64bdAF62C37EEFFCb",
@@ -2301,9 +2413,13 @@ const chains$1 = {
 		...anvil,
 		id: ChainId.ANVIL,
 		name: "anvil",
+		contracts: { multicall3: {
+			address: "0x9fE46736679d2D9a65F0992F2272dE9f3c7fa6e0",
+			blockCreated: 0
+		} },
 		custom: {
 			morpho: {
-				address: "0x23DFBc4B8B80C14CC5e25011B8491f268395BAd6",
+				address: "0xe7f1725E7734CE288F8367e1Bb143E90bb3F0512",
 				blockCreated: 0
 			},
 			morphoBlue: {
@@ -2311,8 +2427,8 @@ const chains$1 = {
 				blockCreated: 0
 			},
 			mempool: {
-				address: "0xD946246695A9259F3B33a78629026F61B3Ab40aF",
-				blockCreated: 23223727
+				address: "0x5FbDB2315678afecb367f032d93F642f64180aa3",
+				blockCreated: 0
 			},
 			vaults: { factories: {
 				v1_0: {
@@ -2514,6 +2630,7 @@ var Random_exports = /* @__PURE__ */ __exportAll({
 	address: () => address,
 	bool: () => bool,
 	bytes: () => bytes,
+	createRng: () => createRng,
 	float: () => float,
 	hex: () => hex,
 	int: () => int,
@@ -2531,7 +2648,19 @@ const hashSeed = (seed) => {
 	}
 	return hash >>> 0;
 };
-const createSeededRng = (seed) => {
+/**
+* Creates an isolated seeded RNG instance — safe for concurrent use.
+* @param seed - Seed string used to derive the initial RNG state.
+*/
+function createRng(seed) {
+	const rng = createSeededRngFn(seed);
+	return {
+		float: () => rng(),
+		int: (maxExclusive, min = 0) => Math.floor(rng() * (maxExclusive - min)) + min,
+		bool: (probability = .5) => rng() < probability
+	};
+}
+const createSeededRngFn = (seed) => {
 	let state = hashSeed(seed);
 	return () => {
 		state += 1831565813;
@@ -2545,7 +2674,7 @@ const createSeededRng = (seed) => {
 */
 function withSeed(seed, fn) {
 	const previous = currentRng;
-	currentRng = createSeededRng(seed);
+	currentRng = createSeededRngFn(seed);
 	try {
 		return fn();
 	} finally {
@@ -2556,7 +2685,7 @@ function withSeed(seed, fn) {
 * Seeds the global RNG for deterministic test runs.
 */
 function seed(seed) {
-	currentRng = createSeededRng(seed);
+	currentRng = createSeededRngFn(seed);
 }
 /**
 * Returns a deterministic random float in [0, 1).
@@ -2678,6 +2807,7 @@ const transformAddress = (val, ctx) => {
 	});
 	return z$1.NEVER;
 };
+const AddressSchema = z$1.string().transform(transformAddress);
 
 //#endregion
 //#region src/core/LLTV.ts
@@ -2752,15 +2882,20 @@ const abi$1 = [
 		type: "uint256",
 		name: "lltv"
 	},
+	{
+		type: "uint256",
+		name: "maxLif"
+	},
 	{
 		type: "address",
 		name: "oracle"
 	}
 ];
 const CollateralSchema = z$1.object({
-	asset: z$1.string().transform(transformAddress),
-	oracle: z$1.string().transform(transformAddress),
-	lltv: LLTVSchema
+	asset: AddressSchema,
+	oracle: AddressSchema,
+	lltv: LLTVSchema,
+	maxLif: z$1.bigint({ coerce: true }).min(0n)
 });
 const CollateralsSchema = z$1.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;
@@ -2778,6 +2913,7 @@ const from$10 = (parameters) => {
 	return {
 		asset: parameters.asset.toLowerCase(),
 		lltv: from$11(parameters.lltv),
+		maxLif: parameters.maxLif,
 		oracle: parameters.oracle.toLowerCase()
 	};
 };
@@ -2794,7 +2930,8 @@ function random$3() {
 	return from$10({
 		asset: address(),
 		oracle: address(),
-		lltv: .965
+		lltv: .965,
+		maxLif: 0n
 	});
 }
 
@@ -2916,14 +3053,8 @@ var Maturity_exports = /* @__PURE__ */ __exportAll({
 	MaturityType: () => MaturityType,
 	from: () => from$9
 });
-const MaturitySchema = z$1.number().int().refine((maturity) => {
-	try {
-		from$9(maturity);
-		return true;
-	} catch (_e) {
-		return false;
-	}
-}, { error: (issue) => {
+const MAX_TIMESTAMP_SECONDS = 999999999999;
+const MaturitySchema = z$1.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 (_) {
@@ -2958,7 +3089,7 @@ function from$9(ts) {
 		if (ts in MaturityOptions) return MaturityOptions[ts]();
 		throw new InvalidOptionError(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;
 }
@@ -3052,10 +3183,10 @@ var Obligation_exports = /* @__PURE__ */ __exportAll({
 	tupleAbi: () => tupleAbi
 });
 const ObligationSchema = z$1.object({
-	loanToken: z$1.string().transform(transformAddress),
+	loanToken: AddressSchema,
 	collaterals: CollateralsSchema,
 	maturity: MaturitySchema,
-	minCollatValue: z$1.bigint({ coerce: true }).min(0n).optional().default(0n)
+	rcfThreshold: z$1.bigint({ coerce: true }).min(0n)
 });
 const abi = [
 	{
@@ -3073,7 +3204,7 @@ const abi = [
 	},
 	{
 		type: "uint256",
-		name: "minCollatValue"
+		name: "rcfThreshold"
 	}
 ];
 const tupleAbi = [{
@@ -3095,10 +3226,12 @@ 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"),
+*   rcfThreshold: 0n,
 * });
 * ```
 */
@@ -3112,7 +3245,7 @@ function from$8(parameters) {
 			loanToken: parsedObligation.loanToken.toLowerCase(),
 			collaterals: parsedObligation.collaterals.sort((a, b) => a.asset.localeCompare(b.asset)),
 			maturity: parsedObligation.maturity,
-			minCollatValue: parsedObligation.minCollatValue
+			rcfThreshold: parsedObligation.rcfThreshold
 		};
 	} catch (error) {
 		throw new InvalidObligationError(error);
@@ -3129,8 +3262,7 @@ function fromSnakeCase$2(input) {
 }
 /**
 * Calculates a canonical key for an obligation payload.
-* The key is computed as keccak256(abi.encode(loanToken, collaterals, maturity, minCollatValue)).
-* If omitted, `minCollatValue` defaults to `0`.
+* The key is computed as keccak256(abi.encode(loanToken, collaterals, maturity, rcfThreshold)).
 * @throws If the collaterals are not sorted alphabetically by address. {@link CollateralsAreNotSortedError}
 * @param parameters - {@link key.Parameters}
 * @returns The obligation key as a 32-byte hex string. {@link key.ReturnType}
@@ -3154,10 +3286,11 @@ function key(parameters) {
 		parameters.collaterals.map((c) => ({
 			token: c.asset.toLowerCase(),
 			lltv: c.lltv,
+			maxLif: c.maxLif,
 			oracle: c.oracle.toLowerCase()
 		})),
 		BigInt(parameters.maturity),
-		parameters.minCollatValue ?? 0n
+		parameters.rcfThreshold
 	]));
 }
 /**
@@ -3173,7 +3306,8 @@ function random$2() {
 	return from$8({
 		loanToken: address(),
 		collaterals: [random$3()],
-		maturity: from$9("end_of_next_quarter")
+		maturity: from$9("end_of_next_quarter"),
+		rcfThreshold: 0n
 	});
 }
 /**
@@ -3187,7 +3321,8 @@ function fromOffer$1(offer) {
 	return from$8({
 		loanToken: offer.loanToken,
 		collaterals: offer.collaterals,
-		maturity: offer.maturity
+		maturity: offer.maturity,
+		rcfThreshold: offer.rcfThreshold
 	});
 }
 var InvalidObligationError = class extends BaseError {
@@ -3224,27 +3359,27 @@ function creationCode(parameters) {
 		collaterals: parameters.obligation.collaterals.map((collateral) => ({
 			token: collateral.asset.toLowerCase(),
 			lltv: collateral.lltv,
+			maxLif: collateral.maxLif,
 			oracle: collateral.oracle.toLowerCase()
 		})),
 		maturity: BigInt(parameters.obligation.maturity),
-		minCollatValue: 0n
+		rcfThreshold: parameters.obligation.rcfThreshold
 	}])]);
 }
 /**
 * Computes the same id as `IdLib.toId` in Solidity using the CREATE2 preimage:
-* `keccak256(0xff ++ morphoV2 ++ chainId ++ keccak256(creationCode))`,
-* then truncates to the lower 20 bytes.
+* `keccak256(0xff ++ morphoV2 ++ chainId ++ keccak256(creationCode))`.
 *
 * @param parameters - {@link toId.Parameters}
-* @returns The obligation id. {@link toId.ReturnType}
+* @returns The 32-byte obligation id. {@link toId.ReturnType}
 */
 function toId(parameters) {
-	return `0x${keccak256(concatHex([
+	return keccak256(concatHex([
 		"0xff",
 		parameters.morphoV2.toLowerCase(),
 		numberToHex(BigInt(parameters.chainId), { size: 32 }),
 		keccak256(creationCode(parameters))
-	])).slice(-40)}`;
+	]));
 }
 
 //#endregion
@@ -3334,7 +3469,6 @@ var Offer_exports = /* @__PURE__ */ __exportAll({
 	fromSnakeCase: () => fromSnakeCase$1,
 	hash: () => hash,
 	liquidateEvent: () => liquidateEvent,
-	obligationId: () => obligationId,
 	random: () => random$1,
 	repayEvent: () => repayEvent,
 	serialize: () => serialize,
@@ -3352,12 +3486,11 @@ let Status = /* @__PURE__ */ function(Status) {
 }({});
 const OfferSchema = () => {
 	return z$1.object({
-		maker: z$1.string().transform(transformAddress),
-		assets: z$1.bigint({ coerce: true }).min(0n).max(maxUint256),
-		obligationUnits: z$1.bigint({ coerce: true }).min(0n).max(maxUint256).optional().default(0n),
-		obligationShares: z$1.bigint({ coerce: true }).min(0n).max(maxUint256).optional().default(0n),
+		maker: AddressSchema,
+		maxUnits: z$1.bigint({ coerce: true }).min(0n).max(maxUint256).optional().default(0n),
 		tick: z$1.coerce.number().int().min(0).max(990),
 		maturity: MaturitySchema,
+		rcfThreshold: z$1.bigint({ coerce: true }).min(0n).max(maxUint256),
 		expiry: z$1.number().int().max(Number.MAX_SAFE_INTEGER),
 		start: z$1.number().int().max(Number.MAX_SAFE_INTEGER),
 		group: z$1.union([
@@ -3371,13 +3504,14 @@ const OfferSchema = () => {
 			z$1.bigint()
 		]).optional().default("0x0000000000000000000000000000000000000000000000000000000000000000").transform(transformBytes32),
 		buy: z$1.boolean(),
-		loanToken: z$1.string().transform(transformAddress),
+		loanToken: AddressSchema,
 		collaterals: CollateralsSchema,
 		callback: z$1.object({
-			address: z$1.string().transform(transformAddress),
+			address: AddressSchema,
 			data: z$1.string().transform(transformHex)
 		}),
-		receiverIfMakerIsSeller: z$1.string().transform(transformAddress)
+		receiverIfMakerIsSeller: AddressSchema,
+		exitOnly: z$1.boolean().optional().default(false)
 	}).refine((data) => data.start < data.expiry, {
 		message: "start must be before expiry",
 		path: ["start"]
@@ -3429,11 +3563,10 @@ function toSnakeCase(offer) {
 */
 const serialize = (offer) => ({
 	maker: offer.maker,
-	assets: offer.assets.toString(),
-	obligationUnits: offer.obligationUnits.toString(),
-	obligationShares: offer.obligationShares.toString(),
+	maxUnits: offer.maxUnits.toString(),
 	tick: offer.tick,
 	maturity: Number(offer.maturity),
+	rcfThreshold: offer.rcfThreshold.toString(),
 	expiry: Number(offer.expiry),
 	start: Number(offer.start),
 	group: offer.group,
@@ -3443,13 +3576,15 @@ const serialize = (offer) => ({
 	collaterals: offer.collaterals.map((c) => ({
 		asset: c.asset,
 		oracle: c.oracle,
-		lltv: c.lltv.toString()
+		lltv: c.lltv.toString(),
+		maxLif: c.maxLif.toString()
 	})),
 	callback: {
 		address: offer.callback.address,
 		data: offer.callback.data
 	},
 	receiverIfMakerIsSeller: offer.receiverIfMakerIsSeller,
+	exitOnly: offer.exitOnly,
 	hash: hash(offer)
 });
 /**
@@ -3486,7 +3621,7 @@ function random$1(config) {
 	const loanTokenDecimals = config?.assetsDecimals?.[loanToken] ?? 18;
 	const unit = BigInt(10) ** BigInt(loanTokenDecimals);
 	const amountBase = BigInt(100 + int(999901));
-	const assetsScaled = config?.assets ?? amountBase * unit;
+	const maxUnitsScaled = config?.maxUnits ?? amountBase * unit;
 	const emptyCallback = {
 		address: zeroAddress,
 		data: "0x"
@@ -3494,11 +3629,10 @@ function random$1(config) {
 	const maker = config?.maker ?? address();
 	return from$7({
 		maker,
-		assets: assetsScaled,
-		obligationUnits: config?.obligationUnits ?? 0n,
-		obligationShares: config?.obligationShares ?? 0n,
+		maxUnits: maxUnitsScaled,
 		tick,
 		maturity,
+		rcfThreshold: config?.rcfThreshold ?? 0n,
 		expiry: config?.expiry ?? maturity - 1,
 		start: config?.start ?? maturity - 10,
 		group: config?.group ?? hex(32),
@@ -3510,7 +3644,8 @@ function random$1(config) {
 			lltv
 		})).sort((a, b) => a.asset.localeCompare(b.asset)),
 		callback: config?.callback ?? emptyCallback,
-		receiverIfMakerIsSeller: config?.receiverIfMakerIsSeller ?? maker
+		receiverIfMakerIsSeller: config?.receiverIfMakerIsSeller ?? maker,
+		exitOnly: config?.exitOnly ?? false
 	});
 }
 const weightedChoice = (pairs) => {
@@ -3537,124 +3672,150 @@ function hash(offer) {
 	return computed;
 }
 /**
-* Calculates the onchain obligation id for an offer.
-* The id is computed with {@link Id.toId}.
-* @param offer - The offer to calculate the obligation id for.
-* @param parameters - The chain context used by the onchain id function.
-* @returns The obligation id as a 20-byte hex string.
+* ABI layout matching the Solidity `Offer` struct used by `abi.encode(offer)` in the contract.
+*
+* This is a **single top-level tuple** — Solidity's `abi.encode(struct)` encodes the struct as one
+* tuple parameter, not as separate parameters per field. Field order and nesting must exactly
+* mirror `contracts/interfaces/IMidnight.sol`:
+*
+* ```
+* struct Offer {
+*     Obligation obligation;  // nested tuple
+*     bool buy;
+*     address maker;
+*     uint256 maxUnits;
+*     uint256 start;
+*     uint256 expiry;
+*     uint256 tick;
+*     bytes32 group;
+*     bytes32 session;
+*     address callback;
+*     bytes callbackData;
+*     address receiverIfMakerIsSeller;
+*     bool exitOnly;
+* }
+* ```
 */
-function obligationId(offer, parameters) {
-	return toId({
-		chainId: parameters.chainId,
-		morphoV2: parameters.morphoV2,
-		obligation: from$8({
-			loanToken: offer.loanToken,
-			collaterals: offer.collaterals,
-			maturity: offer.maturity
-		})
-	});
-}
-const OfferAbi = [
-	{
-		name: "maker",
-		type: "address"
-	},
-	{
-		name: "assets",
-		type: "uint256"
-	},
-	{
-		name: "obligationUnits",
-		type: "uint256"
-	},
-	{
-		name: "obligationShares",
-		type: "uint256"
-	},
-	{
-		name: "tick",
-		type: "uint256"
-	},
-	{
-		name: "maturity",
-		type: "uint256"
-	},
-	{
-		name: "expiry",
-		type: "uint256"
-	},
-	{
-		name: "group",
-		type: "bytes32"
-	},
-	{
-		name: "session",
-		type: "bytes32"
-	},
-	{
-		name: "buy",
-		type: "bool"
-	},
-	{
-		name: "loanToken",
-		type: "address"
-	},
-	{
-		name: "start",
-		type: "uint256"
-	},
-	{
-		name: "collaterals",
-		type: "tuple[]",
-		components: [
-			{
-				name: "asset",
-				type: "address"
-			},
-			{
-				name: "oracle",
-				type: "address"
-			},
-			{
-				name: "lltv",
-				type: "uint256"
-			}
-		]
-	},
-	{
-		name: "callback",
-		type: "tuple",
-		components: [{
-			name: "address",
+const OfferAbi = [{
+	name: "offer",
+	type: "tuple",
+	components: [
+		{
+			name: "obligation",
+			type: "tuple",
+			components: [
+				{
+					name: "loanToken",
+					type: "address"
+				},
+				{
+					name: "collaterals",
+					type: "tuple[]",
+					components: [
+						{
+							name: "token",
+							type: "address"
+						},
+						{
+							name: "lltv",
+							type: "uint256"
+						},
+						{
+							name: "maxLif",
+							type: "uint256"
+						},
+						{
+							name: "oracle",
+							type: "address"
+						}
+					]
+				},
+				{
+					name: "maturity",
+					type: "uint256"
+				},
+				{
+					name: "rcfThreshold",
+					type: "uint256"
+				}
+			]
+		},
+		{
+			name: "buy",
+			type: "bool"
+		},
+		{
+			name: "maker",
 			type: "address"
-		}, {
-			name: "data",
+		},
+		{
+			name: "maxUnits",
+			type: "uint256"
+		},
+		{
+			name: "start",
+			type: "uint256"
+		},
+		{
+			name: "expiry",
+			type: "uint256"
+		},
+		{
+			name: "tick",
+			type: "uint256"
+		},
+		{
+			name: "group",
+			type: "bytes32"
+		},
+		{
+			name: "session",
+			type: "bytes32"
+		},
+		{
+			name: "callback",
+			type: "address"
+		},
+		{
+			name: "callbackData",
 			type: "bytes"
-		}]
-	},
-	{
-		name: "receiverIfMakerIsSeller",
-		type: "address"
-	}
-];
+		},
+		{
+			name: "receiverIfMakerIsSeller",
+			type: "address"
+		},
+		{
+			name: "exitOnly",
+			type: "bool"
+		}
+	]
+}];
 function encode$1(offer) {
-	return encodeAbiParameters(OfferAbi, [
-		offer.maker,
-		offer.assets,
-		offer.obligationUnits,
-		offer.obligationShares,
-		BigInt(offer.tick),
-		BigInt(offer.maturity),
-		BigInt(offer.expiry),
-		offer.group,
-		offer.session,
-		offer.buy,
-		offer.loanToken,
-		BigInt(offer.start),
-		offer.collaterals,
-		offer.callback,
-		offer.receiverIfMakerIsSeller
-	]);
+	return encodeAbiParameters(OfferAbi, [{
+		obligation: {
+			loanToken: offer.loanToken,
+			collaterals: offer.collaterals.map((c) => ({
+				token: c.asset,
+				lltv: c.lltv,
+				maxLif: c.maxLif,
+				oracle: c.oracle
+			})),
+			maturity: BigInt(offer.maturity),
+			rcfThreshold: offer.rcfThreshold
+		},
+		buy: offer.buy,
+		maker: offer.maker,
+		maxUnits: offer.maxUnits,
+		start: BigInt(offer.start),
+		expiry: BigInt(offer.expiry),
+		tick: BigInt(offer.tick),
+		group: offer.group,
+		session: offer.session,
+		callback: offer.callback.address,
+		callbackData: offer.callback.data,
+		receiverIfMakerIsSeller: offer.receiverIfMakerIsSeller,
+		exitOnly: offer.exitOnly
+	}]);
 }
 function decode$1(data) {
 	let decoded;
@@ -3663,31 +3824,33 @@ function decode$1(data) {
 	} catch (error) {
 		throw new InvalidOfferError(error);
 	}
+	const s = decoded[0];
 	return from$7({
-		maker: decoded[0],
-		assets: decoded[1],
-		obligationUnits: decoded[2],
-		obligationShares: decoded[3],
-		tick: Number(decoded[4]),
-		maturity: from$9(Number(decoded[5])),
-		expiry: Number(decoded[6]),
-		group: decoded[7],
-		session: decoded[8],
-		buy: decoded[9],
-		loanToken: decoded[10],
-		start: Number(decoded[11]),
-		collaterals: decoded[12].map((c) => {
+		loanToken: s.obligation.loanToken,
+		collaterals: s.obligation.collaterals.map((c) => {
 			return from$10({
-				asset: c.asset,
+				asset: c.token,
 				oracle: c.oracle,
-				lltv: c.lltv
+				lltv: c.lltv,
+				maxLif: c.maxLif
 			});
 		}),
+		maturity: from$9(Number(s.obligation.maturity)),
+		rcfThreshold: s.obligation.rcfThreshold,
+		buy: s.buy,
+		maker: s.maker,
+		maxUnits: s.maxUnits,
+		start: Number(s.start),
+		expiry: Number(s.expiry),
+		tick: Number(s.tick),
+		group: s.group,
+		session: s.session,
 		callback: {
-			address: decoded[13].address,
-			data: decoded[13].data
+			address: s.callback,
+			data: s.callbackData
 		},
-		receiverIfMakerIsSeller: decoded[14]
+		receiverIfMakerIsSeller: s.receiverIfMakerIsSeller,
+		exitOnly: s.exitOnly
 	});
 }
 /**
@@ -3705,9 +3868,9 @@ const takeEvent = {
 		},
 		{
 			name: "id_",
-			type: "bytes20",
+			type: "bytes32",
 			indexed: true,
-			internalType: "bytes20"
+			internalType: "bytes32"
 		},
 		{
 			name: "maker",
@@ -3740,29 +3903,11 @@ const takeEvent = {
 			internalType: "uint256"
 		},
 		{
-			name: "obligationUnits",
+			name: "units",
 			type: "uint256",
 			indexed: false,
 			internalType: "uint256"
 		},
-		{
-			name: "obligationShares",
-			type: "uint256",
-			indexed: false,
-			internalType: "uint256"
-		},
-		{
-			name: "buyerIsLender",
-			type: "bool",
-			indexed: false,
-			internalType: "bool"
-		},
-		{
-			name: "sellerIsBorrower",
-			type: "bool",
-			indexed: false,
-			internalType: "bool"
-		},
 		{
 			name: "sellerReceiver",
 			type: "address",
@@ -3780,19 +3925,31 @@ const takeEvent = {
 			type: "uint256",
 			indexed: false,
 			internalType: "uint256"
+		},
+		{
+			name: "totalUnits",
+			type: "uint256",
+			indexed: false,
+			internalType: "uint256"
 		}
 	],
 	anonymous: false
 };
 /**
-* ABI for the Consume event emitted by the Obligation contract.
+* ABI for the SetConsumed event emitted by the Morpho V2 contract.
 */
 const consumedEvent = {
 	type: "event",
-	name: "Consume",
+	name: "SetConsumed",
 	inputs: [
 		{
-			name: "user",
+			name: "caller",
+			type: "address",
+			indexed: true,
+			internalType: "address"
+		},
+		{
+			name: "onBehalf",
 			type: "address",
 			indexed: true,
 			internalType: "address"
@@ -3827,12 +3984,12 @@ const repayEvent = {
 		},
 		{
 			name: "id_",
-			type: "bytes20",
+			type: "bytes32",
 			indexed: true,
-			internalType: "bytes20"
+			internalType: "bytes32"
 		},
 		{
-			name: "obligationUnits",
+			name: "units",
 			type: "uint256",
 			indexed: false,
 			internalType: "uint256"
@@ -3861,9 +4018,9 @@ const liquidateEvent = {
 		},
 		{
 			name: "id_",
-			type: "bytes20",
+			type: "bytes32",
 			indexed: true,
-			internalType: "bytes20"
+			internalType: "bytes32"
 		},
 		{
 			name: "collateralIndex",
@@ -3894,6 +4051,12 @@ const liquidateEvent = {
 			type: "uint256",
 			indexed: false,
 			internalType: "uint256"
+		},
+		{
+			name: "latestLossIndex",
+			type: "uint256",
+			indexed: false,
+			internalType: "uint256"
 		}
 	],
 	anonymous: false
@@ -3913,9 +4076,9 @@ const supplyCollateralEvent = {
 		},
 		{
 			name: "id_",
-			type: "bytes20",
+			type: "bytes32",
 			indexed: true,
-			internalType: "bytes20"
+			internalType: "bytes32"
 		},
 		{
 			name: "collateral",
@@ -3953,9 +4116,9 @@ const withdrawCollateralEvent = {
 		},
 		{
 			name: "id_",
-			type: "bytes20",
+			type: "bytes32",
 			indexed: true,
-			internalType: "bytes20"
+			internalType: "bytes32"
 		},
 		{
 			name: "collateral",
@@ -4228,7 +4391,7 @@ var TradingFee_exports = /* @__PURE__ */ __exportAll({
 });
 /**
 * Time breakpoints in seconds for piecewise linear fee interpolation.
-* Matches on-chain constants: 0d, 1d, 7d, 30d, 90d, 180d.
+* Matches on-chain constants: 0d, 1d, 7d, 30d, 90d, 180d, 360d.
 */
 const BREAKPOINTS = [
 	0n,
@@ -4236,21 +4399,22 @@ const BREAKPOINTS = [
 	604800n,
 	2592000n,
 	7776000n,
-	15552000n
+	15552000n,
+	31104000n
 ];
 /** WAD constant (1e18) for fee scaling. */
 const WAD = 10n ** 18n;
 /**
-* Create a TradingFee from an activation flag and 6 fee values.
+* Create a TradingFee from an activation flag and 7 fee values.
 * @param activated - Whether the fee is active.
-* @param fees - Tuple of 6 fee values in WAD (one per breakpoint: 0d, 1d, 7d, 30d, 90d, 180d).
+* @param fees - Tuple of 7 fee values in WAD (one per breakpoint: 0d, 1d, 7d, 30d, 90d, 180d, 360d).
 * @returns A new TradingFee instance.
 * @throws {@link InvalidFeeError} if any fee exceeds WAD (100%).
-* @throws {@link InvalidFeesLengthError} if fees array doesn't have exactly 6 elements.
+* @throws {@link InvalidFeesLengthError} if fees array doesn't have exactly 7 elements.
 */
 function from$3(activated, fees) {
-	if (fees.length !== 6) throw new InvalidFeesLengthError(fees.length);
-	for (let i = 0; i < 6; i++) {
+	if (fees.length !== 7) throw new InvalidFeesLengthError(fees.length);
+	for (let i = 0; i < 7; i++) {
 		const fee = fees[i];
 		if (fee < 0n || fee > WAD) throw new InvalidFeeError(fee, i);
 	}
@@ -4269,7 +4433,9 @@ function from$3(activated, fees) {
 function compute(tradingFee, timeToMaturity) {
 	if (!tradingFee._activated) return 0n;
 	const time = BigInt(Math.max(0, Math.floor(timeToMaturity)));
-	if (time >= BREAKPOINTS[5]) return tradingFee._fees[5];
+	const maxBreakpoint = BREAKPOINTS[BREAKPOINTS.length - 1];
+	const maxFee = tradingFee._fees[tradingFee._fees.length - 1];
+	if (time >= maxBreakpoint) return maxFee;
 	const { index, start, end } = getSegment(time);
 	const feeLower = tradingFee._fees[index];
 	const feeUpper = tradingFee._fees[index + 1];
@@ -4309,7 +4475,7 @@ function deactivate(tradingFee) {
 /**
 * Get the fee values at each breakpoint.
 * @param tradingFee - The TradingFee instance.
-* @returns The tuple of 6 fee values.
+* @returns The tuple of 7 fee values.
 */
 function getFees(tradingFee) {
 	return tradingFee._fees;
@@ -4320,30 +4486,21 @@ function getFees(tradingFee) {
 * @returns Object with index, start, and end of the segment.
 */
 function getSegment(timeToMaturity) {
-	if (timeToMaturity < BREAKPOINTS[1]) return {
-		index: 0,
-		start: BREAKPOINTS[0],
-		end: BREAKPOINTS[1]
-	};
-	if (timeToMaturity < BREAKPOINTS[2]) return {
-		index: 1,
-		start: BREAKPOINTS[1],
-		end: BREAKPOINTS[2]
-	};
-	if (timeToMaturity < BREAKPOINTS[3]) return {
-		index: 2,
-		start: BREAKPOINTS[2],
-		end: BREAKPOINTS[3]
-	};
-	if (timeToMaturity < BREAKPOINTS[4]) return {
-		index: 3,
-		start: BREAKPOINTS[3],
-		end: BREAKPOINTS[4]
-	};
+	for (let segmentEndIndex = 1; segmentEndIndex < BREAKPOINTS.length; segmentEndIndex++) {
+		const end = BREAKPOINTS[segmentEndIndex];
+		if (timeToMaturity < end) {
+			const index = segmentEndIndex - 1;
+			return {
+				index,
+				start: BREAKPOINTS[index],
+				end
+			};
+		}
+	}
 	return {
-		index: 4,
-		start: BREAKPOINTS[4],
-		end: BREAKPOINTS[5]
+		index: BREAKPOINTS.length - 2,
+		start: BREAKPOINTS[BREAKPOINTS.length - 2],
+		end: BREAKPOINTS[BREAKPOINTS.length - 1]
 	};
 }
 /** Error thrown when a fee value is invalid (negative or exceeds WAD). */
@@ -4353,11 +4510,11 @@ var InvalidFeeError = class extends BaseError {
 		super(`Invalid fee at index ${index}: ${fee}. Fee must be between 0 and ${WAD} (WAD).`);
 	}
 };
-/** Error thrown when fees array doesn't have exactly 6 elements. */
+/** Error thrown when fees array doesn't have exactly 7 elements. */
 var InvalidFeesLengthError = class extends BaseError {
 	name = "TradingFee.InvalidFeesLengthError";
 	constructor(length) {
-		super(`Invalid fees length: ${length}. Expected exactly 6 fee values.`);
+		super(`Invalid fees length: ${length}. Expected exactly 7 fee values.`);
 	}
 };
 
@@ -4395,6 +4552,9 @@ function from$2(parameters) {
 var Tree_exports = /* @__PURE__ */ __exportAll({
 	DecodeError: () => DecodeError,
 	EncodeError: () => EncodeError,
+	MAX_COMPRESSED_OFFERS_BYTES: () => MAX_COMPRESSED_OFFERS_BYTES,
+	MAX_DECOMPRESSED_OFFERS_BYTES: () => MAX_DECOMPRESSED_OFFERS_BYTES,
+	MAX_OFFERS_PER_TREE: () => MAX_OFFERS_PER_TREE,
 	SignatureDomainError: () => SignatureDomainError,
 	TreeError: () => TreeError,
 	VERSION: () => VERSION$1,
@@ -4406,7 +4566,16 @@ var Tree_exports = /* @__PURE__ */ __exportAll({
 	signatureDomain: () => signatureDomain,
 	signatureTypes: () => signatureTypes
 });
-const VERSION$1 = 1;
+const VERSION$1 = 2;
+const MAX_COMPRESSED_OFFERS_BYTES = 1e6;
+const MAX_DECOMPRESSED_OFFERS_BYTES = 4e6;
+const MAX_OFFERS_PER_TREE = 100;
+const ROOT_BYTES = 32;
+const SIGNATURE_BYTES = 65;
+const MIN_SIGNED_PAYLOAD_BYTES = 1 + ROOT_BYTES + SIGNATURE_BYTES;
+const INFLATE_INPUT_CHUNK_BYTES = 64 * 1024;
+const UTF8_ENCODER = new TextEncoder();
+const UTF8_DECODER = new TextDecoder();
 /**
 * EIP-712 types for signing the tree root (Root(bytes32 root)).
 */
@@ -4423,29 +4592,83 @@ const signatureTypes = {
 		type: "bytes32"
 	}]
 };
-const normalizeHash = (hash) => hash.toLowerCase();
+const gzipOffersPayload = (payload, errorFactory) => {
+	const payloadBytes = UTF8_ENCODER.encode(payload);
+	if (payloadBytes.length > MAX_DECOMPRESSED_OFFERS_BYTES) throw errorFactory(`decompressed offers exceed ${MAX_DECOMPRESSED_OFFERS_BYTES} bytes`);
+	try {
+		const compressed = gzip(payloadBytes);
+		if (compressed.length > MAX_COMPRESSED_OFFERS_BYTES) throw errorFactory(`compressed offers exceed ${MAX_COMPRESSED_OFFERS_BYTES} bytes`);
+		return compressed;
+	} catch (error) {
+		if (error instanceof BaseError) throw error;
+		throw errorFactory("compression failed");
+	}
+};
+const gunzipOffersPayload = (compressed, errorFactory) => {
+	if (compressed.length === 0) throw errorFactory("decompression failed");
+	if (compressed.length > MAX_COMPRESSED_OFFERS_BYTES) throw errorFactory(`compressed offers exceed ${MAX_COMPRESSED_OFFERS_BYTES} bytes`);
+	let totalLength = 0;
+	const inflate = new Inflate();
+	const defaultOnData = inflate.onData.bind(inflate);
+	inflate.onData = (chunk) => {
+		totalLength += chunk.length;
+		if (totalLength > MAX_DECOMPRESSED_OFFERS_BYTES) throw errorFactory(`decompressed offers exceed ${MAX_DECOMPRESSED_OFFERS_BYTES} bytes`);
+		defaultOnData(chunk);
+	};
+	try {
+		for (let offset = 0; offset < compressed.length; offset += INFLATE_INPUT_CHUNK_BYTES) {
+			const end = Math.min(offset + INFLATE_INPUT_CHUNK_BYTES, compressed.length);
+			inflate.push(compressed.subarray(offset, end), end === compressed.length);
+		}
+	} catch (error) {
+		if (error instanceof BaseError) throw error;
+		throw errorFactory("decompression failed");
+	}
+	if (inflate.err !== 0) throw errorFactory(inflate.msg || "decompression failed");
+	if (!(inflate.result instanceof Uint8Array)) throw errorFactory("decompression failed");
+	return UTF8_DECODER.decode(inflate.result);
+};
+const parseRawOffersPayload = (decoded, errorFactory) => {
+	let rawOffers;
+	try {
+		rawOffers = JSON.parse(decoded);
+	} catch {
+		throw errorFactory("JSON parse failed");
+	}
+	if (!Array.isArray(rawOffers)) throw errorFactory("offers payload must be a JSON array");
+	if (rawOffers.length > MAX_OFFERS_PER_TREE) throw errorFactory(`offers payload exceeds ${MAX_OFFERS_PER_TREE} offers`);
+	return rawOffers;
+};
+const assertUniqueOfferHashes = (offers, errorFactory) => {
+	const seen = /* @__PURE__ */ new Set();
+	for (const offer of offers) {
+		const hash$1 = hash(offer);
+		if (seen.has(hash$1)) throw errorFactory(`duplicate offer hash ${hash$1}`);
+		seen.add(hash$1);
+	}
+};
 /**
 * Builds a Merkle tree from a list of offers.
 *
 * Leaves are the offer `hash` values as `bytes32` and are deterministically
-* ordered following the StandardMerkleTree leaf ordering so that the resulting
-* root is stable regardless of the input order.
+* ordered so that the resulting root is stable regardless of the input order.
 *
 * @param offers - Offers to include in the tree.
-* @returns A `StandardMerkleTree` of `bytes32` leaves representing the offers.
+* @returns A `SimpleMerkleTree` of offer hashes representing the offers.
 * @throws {TreeError} If tree building fails due to offer inconsistencies.
 */
 const from$1 = (offers) => {
-	const leaves = offers.map((offer) => [hash(offer)]);
-	const tree = StandardMerkleTree.of(leaves, ["bytes32"]);
+	assertUniqueOfferHashes(offers, (reason) => new TreeError(reason));
+	const leaves = offers.map((offer) => hash(offer));
+	const tree = SimpleMerkleTree.of(leaves);
 	const orderedOffers = orderOffers(tree, offers);
 	return Object.assign(tree, { offers: orderedOffers });
 };
 const orderOffers = (tree, offers) => {
 	const offerByHash = /* @__PURE__ */ new Map();
-	for (const offer of offers) offerByHash.set(normalizeHash(hash(offer)), offer);
+	for (const offer of offers) offerByHash.set(hash(offer), offer);
 	const entries = tree.dump().values.map((value) => {
-		const hash = normalizeHash(value.value[0]);
+		const hash = value.value;
 		const offer = offerByHash.get(hash);
 		if (!offer) throw new TreeError(`missing offer for leaf ${hash}`);
 		return {
@@ -4460,7 +4683,7 @@ const orderOffers = (tree, offers) => {
 * Generates merkle proofs for all offers in a tree.
 *
 * Each proof allows independent verification that an offer is included in the tree
-* without requiring the full tree. Proofs are ordered by StandardMerkleTree leaf ordering.
+* without requiring the full tree.
 *
 * @param tree - The {@link Tree} to generate proofs for.
 * @returns Array of proofs - {@link Proof}
@@ -4469,7 +4692,7 @@ const proofs = (tree) => {
 	return tree.offers.map((offer) => {
 		return {
 			offer,
-			path: tree.getProof([hash(offer)])
+			path: tree.getProof(hash(offer))
 		};
 	});
 };
@@ -4601,14 +4824,15 @@ const encodeUnsigned = (tree) => {
 };
 const validateTreeForEncoding = (tree) => {
 	if (VERSION$1 > 255) throw new EncodeError(`version overflow: ${VERSION$1} exceeds 255`);
+	if (tree.offers.length > MAX_OFFERS_PER_TREE) throw new EncodeError(`offers payload exceeds ${MAX_OFFERS_PER_TREE} offers`);
 	const computed = from$1(tree.offers);
 	if (tree.root !== computed.root) throw new EncodeError(`root mismatch: expected ${computed.root}, got ${tree.root}`);
 };
 const encodeUnsignedBytes = (tree) => {
 	const offersPayload = tree.offers.map(serialize);
-	const compressed = gzip(JSON.stringify(offersPayload));
+	const compressed = gzipOffersPayload(JSON.stringify(offersPayload), (reason) => new EncodeError(reason));
 	const rootBytes = hexToBytes(tree.root);
-	const encoded = new Uint8Array(1 + compressed.length + 32);
+	const encoded = new Uint8Array(1 + compressed.length + ROOT_BYTES);
 	encoded[0] = VERSION$1;
 	encoded.set(compressed, 1);
 	encoded.set(rootBytes, 1 + compressed.length);
@@ -4621,10 +4845,11 @@ const encodeUnsignedBytes = (tree) => {
 * Returns the tree with separately validated signature and recovered signer address.
 *
 * Validation order:
-* 1. Version check
+* 1. Version and static size checks
 * 2. Signature verification (fail-fast, before decompression)
-* 3. Decompression (only if signature valid)
-* 4. Root verification (computed from offers vs embedded root)
+* 3. Streaming decompression with byte cap
+* 4. JSON array + offer count checks
+* 5. Root verification (computed from offers vs embedded root)
 *
 * @example
 * ```typescript
@@ -4641,33 +4866,20 @@ const decode = async (encoded, domain) => {
 	const errorFactory = (reason) => new DecodeError(reason);
 	const normalizedDomain = normalizeSignatureDomain(domain, errorFactory);
 	const bytes = hexToBytes(encoded);
-	if (bytes.length < 98) throw new DecodeError("payload too short");
+	if (bytes.length < MIN_SIGNED_PAYLOAD_BYTES) throw new DecodeError("payload too short");
 	const version = bytes[0];
 	if (version !== (VERSION$1 & 255)) throw new DecodeError(`invalid version: expected ${VERSION$1}, got ${version ?? 0}`);
-	const signature = bytesToHex(bytes.slice(-65));
-	const root = bytesToHex(bytes.slice(-97, -65));
-	assertHex(root, 32, "root");
-	assertHex(signature, 65, "signature");
+	const signature = bytesToHex(bytes.slice(-SIGNATURE_BYTES));
+	const root = bytesToHex(bytes.slice(-(ROOT_BYTES + SIGNATURE_BYTES), -SIGNATURE_BYTES));
+	assertHex(root, ROOT_BYTES, "root");
+	assertHex(signature, SIGNATURE_BYTES, "signature");
 	const signer = await verifySignatureAndRecoverAddress({
 		root,
 		signature,
 		domain: normalizedDomain,
 		errorFactory
 	});
-	const compressed = bytes.slice(1, -97);
-	let decoded;
-	try {
-		decoded = ungzip(compressed, { to: "string" });
-	} catch {
-		throw new DecodeError("decompression failed");
-	}
-	let rawOffers;
-	try {
-		rawOffers = JSON.parse(decoded);
-	} catch {
-		throw new DecodeError("JSON parse failed");
-	}
-	const tree = from$1(rawOffers.map((o) => OfferSchema().parse(o)));
+	const tree = from$1(parseRawOffersPayload(gunzipOffersPayload(bytes.slice(1, -(ROOT_BYTES + SIGNATURE_BYTES)), errorFactory), errorFactory).map((o) => OfferSchema().parse(o)));
 	if (root !== tree.root) throw new DecodeError(`root mismatch: expected ${tree.root}, got ${root}`);
 	return {
 		tree,
@@ -4786,11 +4998,10 @@ async function getOffers(apiClient, parameters) {
 		return {
 			...fromSnakeCase$1({
 				maker: offerData.maker,
-				assets: offerData.assets,
-				obligation_units: offerData.obligation_units,
-				obligation_shares: offerData.obligation_shares,
+				max_units: offerData.max_units,
 				tick: offerData.tick,
 				maturity: from$9(offerData.obligation.maturity),
+				rcf_threshold: offerData.obligation.rcf_threshold,
 				expiry: offerData.expiry,
 				start: offerData.start,
 				group: offerData.group,
@@ -4800,13 +5011,15 @@ async function getOffers(apiClient, parameters) {
 				collaterals: offerData.obligation.collaterals.map((collateral) => ({
 					asset: collateral.token,
 					oracle: collateral.oracle,
-					lltv: collateral.lltv
+					lltv: collateral.lltv,
+					max_lif: collateral.max_lif
 				})),
 				callback: {
 					address: offerData.callback,
 					data: offerData.callback_data
 				},
-				receiver_if_maker_is_seller: offerData.receiver_if_maker_is_seller
+				receiver_if_maker_is_seller: offerData.receiver_if_maker_is_seller,
+				exit_only: offerData.exit_only ?? false
 			}),
 			hash: item.offer_hash,
 			consumed: BigInt(item.consumed),
@@ -4847,9 +5060,11 @@ async function getObligations(apiClient, parameters) {
 			collaterals: item.collaterals.map((collateral) => ({
 				asset: collateral.token,
 				oracle: collateral.oracle,
-				lltv: collateral.lltv
+				lltv: collateral.lltv,
+				max_lif: collateral.max_lif
 			})),
-			maturity: from$9(item.maturity)
+			maturity: from$9(item.maturity),
+			rcf_threshold: item.rcf_threshold
 		});
 		const { obligationId: _, ...quote } = from$4({
 			obligationId: item.id,
@@ -5140,7 +5355,6 @@ const assets = {
 		"0x833589fCD6eDb6E08f4c7C32D4f71b54bdA02913",
 		"0x50c5725949A6F0c72E6C4a641F24049A917DB0Cb",
 		"0x4200000000000000000000000000000000000006",
-		"0x2260FAC5E5542a773Aa44fBCfeDf7C193bc2C599",
 		"0xcbB7C0000aB88B473b1f5aFd9ef808440eed33Bf",
 		"0xc1CBa3fCea344f92D9239c08C0568f6F2F0ee452",
 		"0x60a3E35Cc302bFA44Cb288Bc5a4F316Fdb1adb42"
@@ -5337,6 +5551,34 @@ function lazy(pollFn) {
 	})();
 }
 
+//#endregion
+//#region src/utils/mapWithConcurrency.ts
+/**
+* Map values with a bounded number of concurrent async workers.
+*
+* Result ordering always matches the input order.
+* @param parameters - Input values, concurrency limit, and async mapper.
+* @returns Mapped results in input order.
+*/
+async function mapWithConcurrency(parameters) {
+	const { values, limit, run } = parameters;
+	if (values.length === 0) return [];
+	const normalizedLimit = Math.max(1, Math.floor(limit));
+	const workerCount = Math.min(normalizedLimit, values.length);
+	const results = new Array(values.length);
+	let nextIndex = 0;
+	const worker = async () => {
+		while (true) {
+			const index = nextIndex;
+			if (index >= values.length) return;
+			nextIndex += 1;
+			results[index] = await run(values[index], index);
+		}
+	};
+	await Promise.all(Array.from({ length: workerCount }, () => worker()));
+	return results;
+}
+
 //#endregion
 //#region src/utils/wait.ts
 async function wait(time) {
@@ -5378,6 +5620,20 @@ function max() {
 	return 0x77e772392b600000;
 }
 
+//#endregion
+//#region src/utils/trim.ts
+/**
+* Keep the last `keep` entries from an array.
+* @param array - Source array.
+* @param keep - Number of entries to keep.
+* @returns Trimmed copy.
+*/
+const trimTail = (array, keep) => {
+	if (!Number.isInteger(keep) || keep < 0) throw new Error(`trimTail: expected non-negative integer keep, got ${keep}`);
+	if (array.length <= keep) return array.slice();
+	return array.slice(array.length - keep);
+};
+
 //#endregion
 //#region src/utils/index.ts
 var utils_exports = /* @__PURE__ */ __exportAll({
@@ -5391,18 +5647,20 @@ var utils_exports = /* @__PURE__ */ __exportAll({
 	batchMulticall: () => batchMulticall,
 	fromSnakeCase: () => fromSnakeCase$3,
 	lazy: () => lazy,
+	mapWithConcurrency: () => mapWithConcurrency,
 	max: () => max$1,
 	min: () => min,
 	poll: () => poll,
 	retry: () => retry,
 	stringifyBigint: () => stringifyBigint,
 	toSnakeCase: () => toSnakeCase$1,
+	trimTail: () => trimTail,
 	wait: () => wait
 });
 
 //#endregion
 //#region src/database/drizzle/VERSION.ts
-const VERSION = "router_v1.13";
+const VERSION = "router_v1.16";
 
 //#endregion
 //#region src/database/drizzle/schema.ts
@@ -5422,6 +5680,7 @@ var EnumTableName = /* @__PURE__ */ function(EnumTableName) {
 	EnumTableName["VALIDATIONS"] = "validations";
 	EnumTableName["COLLECTORS"] = "collectors";
 	EnumTableName["CHAINS"] = "chains";
+	EnumTableName["PENDING_LINKS"] = "pending_links";
 	EnumTableName["LOTS"] = "lots";
 	EnumTableName["LOTS_POSITIONS"] = "lots_positions";
 	EnumTableName["OFFSETS"] = "offsets";
@@ -5434,10 +5693,14 @@ const VERSIONED_TABLE_NAMES = TABLE_NAMES.map((table) => `"${VERSION}"."${table}
 const obligations = s.table(EnumTableName.OBLIGATIONS, {
 	obligationKey: varchar("obligation_key", { length: 66 }).primaryKey(),
 	loanToken: varchar("loan_token", { length: 42 }).notNull(),
-	maturity: integer("maturity").notNull()
+	maturity: integer("maturity").notNull(),
+	rcfThreshold: numeric("rcf_threshold", {
+		precision: 78,
+		scale: 0
+	}).notNull()
 });
 const obligationIdKeys = s.table(EnumTableName.OBLIGATION_ID_KEYS, {
-	obligationId: varchar("obligation_id", { length: 42 }).primaryKey(),
+	obligationId: varchar("obligation_id", { length: 66 }).primaryKey(),
 	obligationKey: varchar("obligation_key", { length: 66 }).notNull().references(() => obligations.obligationKey, { onDelete: "cascade" }),
 	chainId: bigint("chain_id", { mode: "number" }).$type().notNull(),
 	morphoV2: varchar("morpho_v2", { length: 42 }).notNull()
@@ -5459,7 +5722,7 @@ const groups = s.table(EnumTableName.GROUPS, {
 		table.group
 	],
 	name: "groups_pk"
-}), index("groups_chain_id_maker_group_consumed_idx").on(table.chainId, table.maker, table.group, table.consumed)]);
+})]);
 const consumedEvents = s.table(EnumTableName.CONSUMED_EVENTS, {
 	eventId: varchar("event_id", { length: 128 }).primaryKey(),
 	chainId: bigint("chain_id", { mode: "number" }).$type().notNull(),
@@ -5493,16 +5756,13 @@ const obligationCollateralsV2 = s.table(EnumTableName.OBLIGATION_COLLATERALS_V2,
 	asset: varchar("asset", { length: 42 }).notNull(),
 	oracleAddress: varchar("oracle_address", { length: 42 }).notNull(),
 	lltv: bigint("lltv", { mode: "bigint" }).notNull(),
+	maxLif: bigint("max_lif", { mode: "bigint" }).notNull(),
 	collateralIndex: integer("collateral_index").notNull(),
 	updatedAt: timestamp("updated_at").defaultNow().notNull()
-}, (table) => [
-	primaryKey({
-		columns: [table.obligationKey, table.asset],
-		name: "obligation_collaterals_v2_pk"
-	}),
-	index("obligation_collaterals_v2_obligation_key_idx").on(table.obligationKey),
-	index("obligation_collaterals_v2_oracle_address_idx").on(table.oracleAddress)
-]);
+}, (table) => [primaryKey({
+	columns: [table.obligationKey, table.asset],
+	name: "obligation_collaterals_v2_pk"
+})]);
 const oracles = s.table(EnumTableName.ORACLES, {
 	chainId: bigint("chain_id", { mode: "number" }).$type().notNull(),
 	address: varchar("address", { length: 42 }).notNull(),
@@ -5518,16 +5778,8 @@ const oracles = s.table(EnumTableName.ORACLES, {
 })]);
 const offers = s.table(EnumTableName.OFFERS, {
 	hash: varchar("hash", { length: 66 }).notNull(),
-	obligationId: varchar("obligation_id", { length: 42 }).notNull().references(() => obligationIdKeys.obligationId, { onDelete: "cascade" }),
-	assets: numeric("assets", {
-		precision: 78,
-		scale: 0
-	}).notNull(),
-	obligationUnits: numeric("obligation_units", {
-		precision: 78,
-		scale: 0
-	}).notNull().default("0"),
-	obligationShares: numeric("obligation_shares", {
+	obligationId: varchar("obligation_id", { length: 66 }).notNull().references(() => obligationIdKeys.obligationId, { onDelete: "cascade" }),
+	maxUnits: numeric("max_units", {
 		precision: 78,
 		scale: 0
 	}).notNull().default("0"),
@@ -5543,6 +5795,7 @@ const offers = s.table(EnumTableName.OFFERS, {
 	callbackAddress: varchar("callback_address", { length: 42 }).notNull(),
 	callbackData: text("callback_data").notNull(),
 	receiverIfMakerIsSeller: varchar("receiver_if_maker_is_seller", { length: 42 }),
+	exitOnly: boolean("exit_only").notNull().default(false),
 	blockNumber: bigint("block_number", { mode: "number" }).notNull(),
 	updatedAt: timestamp("updated_at").defaultNow().notNull()
 }, (table) => [
@@ -5563,13 +5816,16 @@ const offers = s.table(EnumTableName.OFFERS, {
 		],
 		name: "offers_groups_fk"
 	}).onDelete("cascade"),
-	index("offers_group_fk_idx").on(table.groupChainId, table.groupMaker, table.group),
 	index("offers_group_and_hash_idx").on(table.groupChainId, table.groupMaker, table.group, table.hash),
-	index("offers_obligation_id_side_idx").on(table.obligationId, table.buy)
+	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`"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(),
-	obligationId: varchar("obligation_id", { length: 42 }).notNull(),
+	obligationId: varchar("obligation_id", { length: 66 }).notNull(),
 	callbackId: varchar("callback_id", { length: 66 })
 }, (table) => [foreignKey({
 	columns: [table.offerHash, table.obligationId],
@@ -5610,7 +5866,7 @@ const lots = s.table(EnumTableName.LOTS, {
 	user: varchar("user", { length: 42 }).notNull(),
 	contract: varchar("contract", { length: 66 }).notNull(),
 	group: varchar("group", { length: 66 }).notNull(),
-	obligationId: varchar("obligation_id", { length: 42 }).notNull(),
+	obligationId: varchar("obligation_id", { length: 66 }).notNull(),
 	lower: numeric("lower", {
 		precision: 78,
 		scale: 0
@@ -5655,40 +5911,45 @@ const lots = s.table(EnumTableName.LOTS, {
 			groups.group
 		],
 		name: "lots_groups_fk"
-	}).onDelete("cascade")
+	}).onDelete("cascade"),
+	index("lots_position_group_obligation_idx").on(table.chainId, table.user, table.group, table.obligationId)
 ]);
 const offsets = s.table(EnumTableName.OFFSETS, {
 	chainId: bigint("chain_id", { mode: "number" }).$type().notNull(),
 	user: varchar("user", { length: 42 }).notNull(),
 	contract: varchar("contract", { length: 66 }).notNull(),
 	group: varchar("group", { length: 66 }).notNull(),
-	obligationId: varchar("obligation_id", { length: 42 }).notNull(),
+	obligationId: varchar("obligation_id", { length: 66 }).notNull(),
 	value: numeric("value", {
 		precision: 78,
 		scale: 0
 	}).notNull()
-}, (table) => [primaryKey({
-	columns: [
-		table.chainId,
-		table.user,
-		table.contract,
-		table.group,
-		table.obligationId
-	],
-	name: "offsets_pk"
-}), foreignKey({
-	columns: [
-		table.chainId,
-		table.contract,
-		table.user
-	],
-	foreignColumns: [
-		lotsPositions.chainId,
-		lotsPositions.contract,
-		lotsPositions.user
-	],
-	name: "offsets_lots_positions_fk"
-}).onDelete("cascade")]);
+}, (table) => [
+	primaryKey({
+		columns: [
+			table.chainId,
+			table.user,
+			table.contract,
+			table.group,
+			table.obligationId
+		],
+		name: "offsets_pk"
+	}),
+	foreignKey({
+		columns: [
+			table.chainId,
+			table.contract,
+			table.user
+		],
+		foreignColumns: [
+			lotsPositions.chainId,
+			lotsPositions.contract,
+			lotsPositions.user
+		],
+		name: "offsets_lots_positions_fk"
+	}).onDelete("cascade"),
+	index("offsets_position_obligation_idx").on(table.chainId, table.contract, table.user, table.obligationId)
+]);
 const PositionTypes = s.enum("position_type", Object.values(Type));
 const positionTypes = s.table("position_types", {
 	id: serial("id").primaryKey(),
@@ -5775,7 +6036,7 @@ const status = s.table("status", {
 });
 const validations = s.table("validations", {
 	offerHash: varchar("offer_hash", { length: 66 }).notNull(),
-	obligationId: varchar("obligation_id", { length: 42 }).notNull(),
+	obligationId: varchar("obligation_id", { length: 66 }).notNull(),
 	statusId: integer("status_id").notNull().references(() => status.id, { onDelete: "no action" }),
 	updatedAt: timestamp("updated_at").defaultNow().notNull()
 }, (table) => [primaryKey({
@@ -5803,8 +6064,33 @@ const chains = s.table(EnumTableName.CHAINS, {
 		precision: 78,
 		scale: 0
 	}).default("0").notNull(),
+	checkpoints: text("checkpoints").default("[]").notNull(),
+	tipHash: text("tip_hash"),
+	finalizedBlockNumber: bigint("finalized_block_number", { mode: "number" }),
+	finalizedBlockHash: text("finalized_block_hash"),
 	updatedAt: timestamp("updated_at").defaultNow().notNull()
 }, (table) => [uniqueIndex("chains_chain_id_idx").on(table.chainId)]);
+const pendingLinks = s.table(EnumTableName.PENDING_LINKS, {
+	key: varchar("key", { length: 191 }).primaryKey(),
+	type: text("type").notNull(),
+	status: text("status").notNull(),
+	chainId: bigint("chain_id", { mode: "number" }).$type().notNull(),
+	eventId: varchar("event_id", { length: 128 }).notNull(),
+	obligationId: varchar("obligation_id", { length: 66 }).notNull(),
+	collateralIndex: integer("collateral_index").notNull(),
+	user: varchar("user", { length: 42 }).notNull(),
+	amount: numeric("amount", {
+		precision: 78,
+		scale: 0
+	}).notNull(),
+	blockNumber: bigint("block_number", { mode: "number" }).notNull(),
+	firstSeenBlock: bigint("first_seen_block", { mode: "number" }).notNull(),
+	lastTriedBlock: bigint("last_tried_block", { mode: "number" }),
+	attempts: integer("attempts").notNull().default(0),
+	ignoredReason: text("ignored_reason"),
+	resolvedAt: timestamp("resolved_at"),
+	updatedAt: timestamp("updated_at").defaultNow().notNull()
+}, (table) => [index("pending_links_pending_scan_idx").on(table.chainId, table.type, table.status, table.firstSeenBlock), index("pending_links_event_id_idx").on(table.chainId, table.eventId)]);
 const trees = s.table(EnumTableName.TREES, {
 	root: varchar("root", { length: 66 }).primaryKey(),
 	rootSignature: varchar("root_signature", { length: 132 }).notNull(),
@@ -5812,7 +6098,7 @@ const trees = s.table(EnumTableName.TREES, {
 });
 const merklePaths = s.table(EnumTableName.MERKLE_PATHS, {
 	offerHash: varchar("offer_hash", { length: 66 }).notNull(),
-	obligationId: varchar("obligation_id", { length: 42 }).notNull(),
+	obligationId: varchar("obligation_id", { length: 66 }).notNull(),
 	treeRoot: varchar("tree_root", { length: 66 }).notNull().references(() => trees.root, { onDelete: "cascade" }),
 	proofNodes: text("proof_nodes").notNull(),
 	createdAt: timestamp("created_at").defaultNow().notNull()
@@ -5839,7 +6125,7 @@ function compositeKey(g) {
 //#endregion
 //#region src/gatekeeper/Rules.ts
 var Rules_exports = /* @__PURE__ */ __exportAll({
-	amountMutualExclusivity: () => amountMutualExclusivity,
+	amountNonZero: () => amountNonZero,
 	callback: () => callback,
 	collateralToken: () => collateralToken,
 	groupConsistency: () => groupConsistency,
@@ -5910,11 +6196,6 @@ const sameMaker = () => batch("mixed_maker", "Validates that all offers in a bat
 	return issues;
 });
 /**
-* A validation rule that ensures mutual exclusivity of offer amount fields.
-* At most one of (assets, obligationUnits, obligationShares) can be non-zero.
-* Matches contract requirement: `atMostOneNonZero(offer.assets, offer.obligationUnits, offer.obligationShares)`.
-*/
-/**
 * A validation rule that checks if the offer duration (expiry - start) meets a minimum threshold.
 * @param minSeconds - Minimum required duration in seconds.
 * @returns The issue that was found. If the offer is valid, this will be undefined.
@@ -5932,14 +6213,20 @@ const minDuration = ({ minSeconds }) => single("min_duration", `Validates that o
 const maxCollaterals = ({ max }) => single("max_collaterals", `Validates that an offer has at most ${max} collaterals`, (offer) => {
 	if (offer.collaterals.length > max) return { message: `Offer has ${offer.collaterals.length} collaterals, exceeding the maximum of ${max}` };
 });
-const amountMutualExclusivity = () => single("amount_mutual_exclusivity", "Validates that at most one of (assets, obligationUnits, obligationShares) is non-zero", (offer) => {
-	if (!atMostOneNonZero(offer.assets, offer.obligationUnits, offer.obligationShares)) return { message: "Inconsistent offer input: at most one of (assets, obligationUnits, obligationShares) must be non-zero" };
+/**
+* A 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 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, assets amount, and side (buy/sell).
+* 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, assets amount, and side", (offers) => {
+const groupConsistency = () => batch("group_consistency", "Validates that all offers in a group have the same loan token, obligation amounts, and side", (offers) => {
 	const issues = /* @__PURE__ */ new Map();
 	if (offers.length === 0) return issues;
 	const groupMap = /* @__PURE__ */ new Map();
@@ -5953,13 +6240,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 refAssets = reference.assets;
+		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.assets !== refAssets) issues.set(idx, { message: `All offers in a group must have the same assets amount. Expected ${refAssets}, got ${offer.assets}` });
+			else if (offer.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"}` });
 		}
 	}
@@ -6016,7 +6303,7 @@ const morphoRules = (parameters) => {
 	}
 	const rules = [
 		sameMaker(),
-		amountMutualExclusivity(),
+		amountNonZero(),
 		groupConsistency(),
 		...config?.minDuration != null ? [minDuration({ minSeconds: config.minDuration })] : [],
 		maturity({ maturities: [MaturityType.EndOfWeek, MaturityType.EndOfNextWeek] }),