@morpho-dev/router 0.10.0 → 0.12.0

package/dist/index.browser.mjs

@@ -6,53 +6,14 @@ import { ApiBody, ApiOperation, ApiParam, ApiProperty, ApiQuery, ApiResponse, Ap
 import * as z$1 from "zod";
 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 { getBlock, getLogs, multicall } from "viem/actions";
+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 { sql } from "drizzle-orm";
+import { bigint, boolean, foreignKey, index, integer, numeric, pgSchema, primaryKey, serial, text, timestamp, uniqueIndex, varchar } from "drizzle-orm/pg-core";
 
-//#region \0@oxc-project+runtime@0.110.0/helpers/typeof.js
-function _typeof(o) {
-	"@babel/helpers - typeof";
-	return _typeof = "function" == typeof Symbol && "symbol" == typeof Symbol.iterator ? function(o) {
-		return typeof o;
-	} : function(o) {
-		return o && "function" == typeof Symbol && o.constructor === Symbol && o !== Symbol.prototype ? "symbol" : typeof o;
-	}, _typeof(o);
-}
-
-//#endregion
-//#region \0@oxc-project+runtime@0.110.0/helpers/toPrimitive.js
-function toPrimitive(t, r) {
-	if ("object" != _typeof(t) || !t) return t;
-	var e = t[Symbol.toPrimitive];
-	if (void 0 !== e) {
-		var i = e.call(t, r || "default");
-		if ("object" != _typeof(i)) return i;
-		throw new TypeError("@@toPrimitive must return a primitive value.");
-	}
-	return ("string" === r ? String : Number)(t);
-}
-
-//#endregion
-//#region \0@oxc-project+runtime@0.110.0/helpers/toPropertyKey.js
-function toPropertyKey(t) {
-	var i = toPrimitive(t, "string");
-	return "symbol" == _typeof(i) ? i : i + "";
-}
-
-//#endregion
-//#region \0@oxc-project+runtime@0.110.0/helpers/defineProperty.js
-function _defineProperty(e, r, t) {
-	return (r = toPropertyKey(r)) in e ? Object.defineProperty(e, r, {
-		value: t,
-		enumerable: !0,
-		configurable: !0,
-		writable: !0
-	}) : e[r] = t, e;
-}
-
-//#endregion
 //#region src/utils/Errors.ts
 var Errors_exports = /* @__PURE__ */ __exportAll({
 	BaseError: () => BaseError,
@@ -68,6 +29,10 @@ var Errors_exports = /* @__PURE__ */ __exportAll({
 * ```
 */
 var BaseError = class BaseError extends Error {
+	details;
+	shortMessage;
+	cause;
+	name = "BaseError";
 	constructor(shortMessage, options = {}) {
 		const details = (() => {
 			if (options.cause instanceof BaseError) {
@@ -84,10 +49,6 @@ var BaseError = class BaseError extends Error {
 			...details ? ["", details ? `Details: ${details}` : void 0] : []
 		].filter((x) => typeof x === "string").join("\n");
 		super(message, options.cause ? { cause: options.cause } : void 0);
-		_defineProperty(this, "details", void 0);
-		_defineProperty(this, "shortMessage", void 0);
-		_defineProperty(this, "cause", void 0);
-		_defineProperty(this, "name", "BaseError");
 		this.cause = options.cause;
 		this.details = details;
 		this.shortMessage = shortMessage;
@@ -103,9 +64,9 @@ function walk(err, fn) {
 	return fn ? null : err;
 }
 var ReorgError = class extends BaseError {
+	name = "ReorgError";
 	constructor(blockNumber) {
 		super(`Reorg detected at block number ${blockNumber}`);
-		_defineProperty(this, "name", "ReorgError");
 	}
 };
 
@@ -116,6 +77,8 @@ var Tick_exports = /* @__PURE__ */ __exportAll({
 	InvalidTickError: () => InvalidTickError,
 	MAX_PRICE: () => MAX_PRICE,
 	TICK_RANGE: () => TICK_RANGE,
+	assetsToObligationUnits: () => assetsToObligationUnits,
+	obligationUnitsToAssets: () => obligationUnitsToAssets,
 	priceToTick: () => priceToTick,
 	tickToPrice: () => tickToPrice
 });
@@ -175,16 +138,36 @@ function assertTick(tick) {
 function assertPrice(price) {
 	if (price < 0n || price > MAX_PRICE) throw new InvalidPriceError(price);
 }
+/**
+* Converts obligation units to assets using the tick price (mulDivDown).
+* @param obligationUnits - The obligation units to convert.
+* @param tick - The offer tick.
+* @returns The equivalent amount in assets.
+*/
+function obligationUnitsToAssets(obligationUnits, tick) {
+	return obligationUnits * tickToPrice(tick) / WAD$1;
+}
+/**
+* Converts assets to obligation units using the tick price (mulDivUp).
+* @param assets - The asset amount to convert.
+* @param tick - The offer tick.
+* @returns The equivalent amount in obligation units.
+*/
+function assetsToObligationUnits(assets, tick) {
+	const price = tickToPrice(tick);
+	if (price === 0n) return 0n;
+	return (assets * WAD$1 + price - 1n) / price;
+}
 var InvalidTickError = class extends BaseError {
+	name = "Tick.InvalidTickError";
 	constructor(tick) {
 		super(`Invalid tick: ${tick}. Tick must be an integer between 0 and ${TICK_RANGE}.`);
-		_defineProperty(this, "name", "Tick.InvalidTickError");
 	}
 };
 var InvalidPriceError = class extends BaseError {
+	name = "Tick.InvalidPriceError";
 	constructor(price) {
 		super(`Invalid price: ${price}. Price must be between 0 and ${MAX_PRICE}.`);
-		_defineProperty(this, "name", "Tick.InvalidPriceError");
 	}
 };
 
@@ -196,7 +179,7 @@ function from$15(level) {
 	return {
 		tick: level.tick,
 		price: price.toString(),
-		assets: level.assets.toString(),
+		obligation_units: level.obligationUnits.toString(),
 		count: level.count
 	};
 }
@@ -254,9 +237,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()
@@ -297,15 +282,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(),
 			start: input.start,
 			expiry: input.expiry,
 			tick: input.tick,
@@ -313,7 +298,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,
@@ -366,15 +352,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",
+		obligation_units: "369216000000000000000000",
 		start: 1761922790,
 		expiry: 1761922799,
 		tick: 495,
@@ -382,10 +368,11 @@ 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: "0x25690ae1aee324a005be565f3bcdd16dbf8daf7969b26c181c8b8f467dad9abc",
+	obligation_id: "0x25690ae1aee324a005be565f3bcdd16dbf8daf79",
 	chain_id: 1,
 	consumed: "0",
 	takeable: "369216000000000000000000",
@@ -416,11 +403,10 @@ const missingCollectorExample = {
 };
 const validateOfferExample = {
 	maker: "0x7b093658BE7f90B63D7c359e8f408e503c2D9401",
-	assets: "369216000000000000000000",
-	obligation_units: "0",
-	obligation_shares: "0",
+	obligation_units: "369216000000000000000000",
 	tick: 495,
 	maturity: 1761922799,
+	rcf_threshold: "0",
 	expiry: 1761922799,
 	start: 1761922790,
 	group: "0x000000000000000000000000000000000000000000000000000000000008b8f4",
@@ -431,13 +417,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",
@@ -481,6 +469,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"
@@ -498,6 +490,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",
@@ -542,6 +538,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,
@@ -555,18 +555,10 @@ __decorate([ApiProperty({
 	type: "string",
 	example: offerExample.offer.maker
 })], 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);
 __decorate([ApiProperty({
 	type: "number",
 	example: offerExample.offer.start
@@ -601,6 +593,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,
@@ -663,6 +659,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 {};
@@ -810,20 +810,11 @@ __decorate([ApiProperty({
 	type: "string",
 	example: validateOfferExample.maker
 })], 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,
-	required: false
-})], ValidateOfferRequest.prototype, "obligation_shares", void 0);
 __decorate([ApiProperty({
 	type: "number",
 	example: validateOfferExample.tick,
@@ -834,6 +825,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
@@ -870,6 +865,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",
@@ -948,7 +948,7 @@ __decorate([ApiProperty({
 __decorate([ApiProperty({
 	type: "string",
 	example: "369216000000000000000000"
-})], BookLevelResponse.prototype, "assets", void 0);
+})], BookLevelResponse.prototype, "obligation_units", void 0);
 __decorate([ApiProperty({
 	type: "number",
 	example: 5
@@ -1572,7 +1572,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",
@@ -1642,11 +1642,14 @@ function isValidBase64urlJson(val) {
 function isValidOfferHashCursor(val) {
 	return /^0x[a-f0-9]{64}$/i.test(val);
 }
+function isValidObligationIdCursor(val) {
+	return /^0x[a-f0-9]{64}$/i.test(val);
+}
 function isValidOfferCursor(val) {
 	const [hash, obligationId, ...rest] = val.split(":");
 	if (rest.length !== 0) return false;
 	if (!hash || !obligationId) return false;
-	return isValidOfferHashCursor(hash) && isValidOfferHashCursor(obligationId);
+	return isValidOfferHashCursor(hash) && isValidObligationIdCursor(obligationId);
 }
 const csvArray = (schema) => z$1.preprocess((value) => {
 	if (value === void 0) return void 0;
@@ -1675,10 +1678,14 @@ const ConfigRuleTypes = z$1.enum([
 	"callback",
 	"loan_token",
 	"collateral_token",
-	"oracle"
+	"oracle",
+	"group_consistency",
+	"group_immutability",
+	"max_collaterals",
+	"min_duration"
 ]);
 const GetConfigRulesQueryParams = z$1.object({
-	cursor: z$1.string().regex(/^(maturity|callback|loan_token|collateral_token|oracle):[1-9]\d*:.+$/, { message: "Cursor must be in the format type:chain_id:<value>" }).optional().meta({
+	cursor: z$1.string().regex(/^(maturity|callback|loan_token|collateral_token|oracle|group_consistency|group_immutability|max_collaterals|min_duration):[1-9]\d*:.+$/, { message: "Cursor must be in the format type:chain_id:<value>" }).optional().meta({
 		description: "Pagination cursor in type:chain_id:<value> format",
 		example: "maturity:1:1730415600:end_of_next_month"
 	}),
@@ -1932,55 +1939,75 @@ const MetaMorphoFactory = parseAbi(["event CreateMetaMorpho(address indexed meta
 //#region src/core/Abi/MorphoV2.ts
 const MorphoV2 = parseAbi([
 	"constructor()",
-	"function collateralOf(bytes32 id, address user, address collateralToken) view returns (uint256)",
-	"function 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 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 index) view returns (uint16)",
+	"function defaultFees(address loanToken, uint256) view returns (uint16)",
 	"function feeSetter() view returns (address)",
-	"function fees(bytes32 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) obligation, bytes32 id, address borrower) view returns (bool)",
-	"function liquidate((address loanToken, (address token, uint256 lltv, address oracle)[] collaterals, uint256 maturity) obligation, (uint256 collateralIndex, uint256 repaid, uint256 seized)[] seizures, address borrower, bytes data) returns ((uint256 collateralIndex, uint256 repaid, uint256 seized)[])",
+	"function 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(bytes32 id) view returns (bool)",
-	"function obligationState(bytes32 id) view returns (uint128 totalUnits, uint128 totalShares, uint256 withdrawable, bool created)",
+	"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) obligation, uint256 obligationUnits, address onBehalf)",
+	"function repay((address loanToken, (address token, uint256 lltv, uint256 maxLif, address oracle)[] collaterals, uint256 maturity, uint256 rcfThreshold) obligation, uint256 obligationUnits, 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 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(bytes32 id, address user) view returns (uint256)",
-	"function shuffleSession()",
-	"function supplyCollateral((address loanToken, (address token, uint256 lltv, address oracle)[] collaterals, uint256 maturity) obligation, address collateral, uint256 assets, address onBehalf)",
-	"function take(uint256 buyerAssets, uint256 sellerAssets, uint256 obligationUnits, uint256 obligationShares, address taker, address takerCallback, bytes takerCallbackData, address receiverIfTakerIsSeller, ((address loanToken, (address token, uint256 lltv, address oracle)[] collaterals, uint256 maturity) obligation, bool buy, address maker, uint256 assets, uint256 obligationUnits, uint256 obligationShares, uint256 start, uint256 expiry, uint256 tick, bytes32 group, bytes32 session, address callback, bytes callbackData, address receiverIfMakerIsSeller) offer, (uint8 v, bytes32 r, bytes32 s) sig, bytes32 root, bytes32[] proof) returns (uint256, uint256, uint256, uint256)",
-	"function totalShares(bytes32 id) view returns (uint256)",
+	"function 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 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, address oracle)[] collaterals, uint256 maturity) obligation) returns (bytes32)",
+	"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) obligation, uint256 obligationUnits, uint256 shares, address onBehalf, address receiver) returns (uint256, uint256)",
-	"function withdrawCollateral((address loanToken, (address token, uint256 lltv, address oracle)[] collaterals, uint256 maturity) obligation, address collateral, uint256 assets, address onBehalf, address receiver)",
+	"function 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 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, bytes32 indexed id, (uint256 collateralIndex, uint256 repaid, uint256 seized)[] seizures, address indexed borrower, uint256 totalRepaid, uint256 badDebt)",
-	"event ObligationCreated(bytes32 indexed id, (address loanToken, (address token, uint256 lltv, address oracle)[] collaterals, uint256 maturity) obligation)",
-	"event Repay(address indexed caller, bytes32 indexed id, uint256 obligationUnits, address indexed onBehalf)",
+	"event Liquidate(address indexed caller, 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 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(bytes32 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, bytes32 indexed id, address indexed collateral, uint256 assets, address indexed onBehalf)",
-	"event Take(address caller, bytes32 indexed id, address indexed maker, address indexed taker, bool offerIsBuy, uint256 buyerAssets, uint256 sellerAssets, uint256 obligationUnits, uint256 obligationShares, bool buyerIsLender, bool sellerIsBorrower, address sellerReceiver, bytes32 group, uint256 consumed)",
-	"event Withdraw(address caller, bytes32 indexed id, uint256 obligationUnits, uint256 shares, address indexed onBehalf, address indexed receiver)",
-	"event WithdrawCollateral(address caller, bytes32 indexed id, address indexed collateral, uint256 assets, address indexed onBehalf, address receiver)"
+	"event 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 WithdrawCollateral(address caller, bytes32 indexed id_, address indexed collateral, uint256 assets, address indexed onBehalf, address receiver)"
 ]);
 
 //#endregion
@@ -2138,6 +2165,7 @@ const Morpho = [
 //#endregion
 //#region src/core/Callback.ts
 var Callback_exports = /* @__PURE__ */ __exportAll({
+	CallbackType: () => CallbackType,
 	Type: () => Type$1,
 	isEmptyCallback: () => isEmptyCallback
 });
@@ -2146,30 +2174,12 @@ let Type$1 = /* @__PURE__ */ function(Type) {
 	Type["SellWithEmptyCallback"] = "sell_with_empty_callback";
 	return Type;
 }({});
+let CallbackType = /* @__PURE__ */ function(CallbackType) {
+	CallbackType["Empty"] = "empty";
+	return CallbackType;
+}({});
 const isEmptyCallback = (offer) => offer.callback.data === "0x";
 
-//#endregion
-//#region src/utils/BigMath.ts
-function max$1(a, b) {
-	return a > b ? a : b;
-}
-function min(a, b) {
-	return a < b ? a : b;
-}
-/**
-* Checks if at most one of the given values is non-zero.
-* @param values - The bigint values to check.
-* @returns True if zero or one value is non-zero, false if two or more are non-zero.
-*/
-function atMostOneNonZero(...values) {
-	let nonZeroCount = 0;
-	for (const value of values) if (value !== 0n) {
-		nonZeroCount++;
-		if (nonZeroCount > 1) return false;
-	}
-	return true;
-}
-
 //#endregion
 //#region src/utils/batch.ts
 /**
@@ -2193,6 +2203,28 @@ function* batch$1(array, batchSize) {
 	for (let i = 0; i < array.length; i += batchSize) yield array.slice(i, i + batchSize);
 }
 
+//#endregion
+//#region src/utils/BigMath.ts
+function max$1(a, b) {
+	return a > b ? a : b;
+}
+function min(a, b) {
+	return a < b ? a : b;
+}
+/**
+* Checks if at most one of the given values is non-zero.
+* @param values - The bigint values to check.
+* @returns True if zero or one value is non-zero, false if two or more are non-zero.
+*/
+function atMostOneNonZero(...values) {
+	let nonZeroCount = 0;
+	for (const value of values) if (value !== 0n) {
+		nonZeroCount++;
+		if (nonZeroCount > 1) return false;
+	}
+	return true;
+}
+
 //#endregion
 //#region src/core/Chain.ts
 var Chain_exports = /* @__PURE__ */ __exportAll({
@@ -2201,9 +2233,10 @@ var Chain_exports = /* @__PURE__ */ __exportAll({
 	InvalidBlockRangeError: () => InvalidBlockRangeError,
 	InvalidBlockWindowError: () => InvalidBlockWindowError,
 	MissingBlockNumberError: () => MissingBlockNumberError,
+	UnrecoverableLogsResponseSizeError: () => UnrecoverableLogsResponseSizeError,
 	chainIds: () => chainIds,
 	chainNames: () => chainNames,
-	chains: () => chains,
+	chains: () => chains$1,
 	getChain: () => getChain,
 	getWhitelistedChains: () => getWhitelistedChains,
 	streamLogs: () => streamLogs
@@ -2220,17 +2253,17 @@ const chainNameLookup = new Map(Object.entries(ChainId).map(([key, value]) => [v
 function getChain(chainId) {
 	const chainName = chainNameLookup.get(chainId);
 	if (!chainName) return void 0;
-	return chains[chainName];
+	return chains$1[chainName];
 }
 const getWhitelistedChains = () => {
 	return [
-		chains.ethereum,
-		chains.base,
-		chains["ethereum-virtual-testnet"],
-		chains.anvil
+		chains$1.ethereum,
+		chains$1.base,
+		chains$1["ethereum-virtual-testnet"],
+		chains$1.anvil
 	];
 };
-const chains = {
+const chains$1 = {
 	ethereum: {
 		...mainnet,
 		id: ChainId.ETHEREUM,
@@ -2267,8 +2300,8 @@ const chains = {
 		name: "base",
 		custom: {
 			morpho: {
-				address: "0x3F067BC9D8898F6ec02D6480c3fF1026E512BcBF",
-				blockCreated: 41799989
+				address: "0xee437005ba0a3d0e9bc6510775c41f23ed2909e1",
+				blockCreated: 43515847
 			},
 			morphoBlue: {
 				address: "0xBBBBBbbBBb9cC5e90e3b3Af64bdAF62C37EEFFCb",
@@ -2297,8 +2330,8 @@ const chains = {
 		name: "ethereum-virtual-testnet",
 		custom: {
 			morpho: {
-				address: "0xc9f3c65996fc46b9500608b2c9a9152c01c540f7",
-				blockCreated: 23226871
+				address: "0xc1c6e6fa308eeef18e96be420d8ccb218215a26c",
+				blockCreated: 23244321
 			},
 			morphoBlue: {
 				address: "0xBBBBBbbBBb9cC5e90e3b3Af64bdAF62C37EEFFCb",
@@ -2325,9 +2358,13 @@ const chains = {
 		...anvil,
 		id: ChainId.ANVIL,
 		name: "anvil",
+		contracts: { multicall3: {
+			address: "0x9fE46736679d2D9a65F0992F2272dE9f3c7fa6e0",
+			blockCreated: 0
+		} },
 		custom: {
 			morpho: {
-				address: "0x23DFBc4B8B80C14CC5e25011B8491f268395BAd6",
+				address: "0xe7f1725E7734CE288F8367e1Bb143E90bb3F0512",
 				blockCreated: 0
 			},
 			morphoBlue: {
@@ -2335,8 +2372,8 @@ const chains = {
 				blockCreated: 0
 			},
 			mempool: {
-				address: "0xD946246695A9259F3B33a78629026F61B3Ab40aF",
-				blockCreated: 23223727
+				address: "0x5FbDB2315678afecb367f032d93F642f64180aa3",
+				blockCreated: 0
 			},
 			vaults: { factories: {
 				v1_0: {
@@ -2356,33 +2393,72 @@ const MAX_BATCH_SIZE = 1e4;
 const DEFAULT_BATCH_SIZE$1 = 2500;
 const MAX_BLOCK_WINDOW = 1e4;
 const DEFAULT_BLOCK_WINDOW = 8e3;
+const MIN_BLOCK_WINDOW = 0n;
+const oversizedLogsErrorPatterns = [
+	"cannot create a string longer than",
+	"response is too big",
+	"response size exceeded",
+	"log response size exceeded",
+	"query returned more than",
+	"too many results"
+];
+const getLatestBlockNumber = async (client) => {
+	return await getBlockNumber(client, { cacheTime: 0 });
+};
 async function* streamLogs(parameters) {
 	const { client, contractAddress, event, blockNumberGte, blockNumberLte, order = "desc", options: { maxBatchSize = DEFAULT_BATCH_SIZE$1, blockWindow = DEFAULT_BLOCK_WINDOW } = {} } = parameters;
 	if (maxBatchSize > MAX_BATCH_SIZE) throw new InvalidBatchSizeError(maxBatchSize);
 	if (blockWindow > MAX_BLOCK_WINDOW) throw new InvalidBlockWindowError(blockWindow);
 	if (order === "asc" && blockNumberGte === void 0) throw new MissingBlockNumberError();
-	const latestBlock = (await getBlock(client, {
-		blockTag: "latest",
-		includeTransactions: false
-	})).number;
+	const ascendingLowerBound = order === "asc" ? BigInt(blockNumberGte) : void 0;
+	const latestBlock = await getLatestBlockNumber(client);
+	let upperBound = blockNumberLte === void 0 ? latestBlock : min(BigInt(blockNumberLte), latestBlock);
+	const lowerBound = BigInt(blockNumberGte || 0);
+	const configuredBlockWindow = BigInt(blockWindow);
+	let adaptiveBlockWindow = configuredBlockWindow;
 	let toBlock = 0n;
-	if (order === "asc") toBlock = min(BigInt(blockNumberGte) + BigInt(blockWindow), blockNumberLte ? BigInt(blockNumberLte) : latestBlock);
-	if (order === "desc") toBlock = blockNumberLte === void 0 ? latestBlock : min(BigInt(blockNumberLte), latestBlock);
+	if (order === "asc") toBlock = min(ascendingLowerBound + adaptiveBlockWindow, upperBound);
+	if (order === "desc") toBlock = upperBound;
 	let fromBlock = 0n;
-	if (order === "asc") fromBlock = min(BigInt(blockNumberGte), latestBlock);
-	if (order === "desc") fromBlock = max$1(BigInt(blockNumberGte || toBlock - BigInt(blockWindow)), 0n);
-	if (order === "asc") toBlock = min(toBlock, fromBlock + BigInt(blockWindow));
-	if (order === "desc") fromBlock = max$1(fromBlock, toBlock - BigInt(blockWindow));
+	if (order === "asc") fromBlock = ascendingLowerBound;
+	if (order === "desc") fromBlock = max$1(BigInt(blockNumberGte || toBlock - adaptiveBlockWindow), 0n);
+	if (order === "asc") toBlock = min(toBlock, fromBlock + adaptiveBlockWindow);
+	if (order === "desc") fromBlock = max$1(fromBlock, toBlock - adaptiveBlockWindow);
 	if (fromBlock > toBlock) throw new InvalidBlockRangeError(fromBlock, toBlock);
 	let streaming = true;
 	while (streaming) {
-		const logs = await getLogs(client, {
-			address: contractAddress,
-			event,
-			fromBlock,
-			toBlock
-		});
-		streaming = order === "asc" ? toBlock < (blockNumberLte || latestBlock) : fromBlock > (blockNumberGte || 0n);
+		let logs;
+		try {
+			logs = await getLogs(client, {
+				address: contractAddress,
+				event,
+				fromBlock,
+				toBlock
+			});
+		} catch (err) {
+			if (order === "asc" && isBlockOutOfRangeError(err)) {
+				const previousUpperBound = upperBound;
+				const previousFromBlock = fromBlock;
+				const previousToBlock = toBlock;
+				const latestBlockOnRetry = await getLatestBlockNumber(client);
+				upperBound = min(upperBound, latestBlockOnRetry);
+				if (upperBound < ascendingLowerBound) throw new InvalidBlockRangeError(ascendingLowerBound, upperBound);
+				toBlock = min(toBlock, upperBound);
+				fromBlock = max$1(min(fromBlock, upperBound), ascendingLowerBound);
+				if (fromBlock > toBlock) throw new InvalidBlockRangeError(fromBlock, toBlock);
+				if (!(upperBound < previousUpperBound || fromBlock < previousFromBlock || toBlock < previousToBlock)) throw err;
+				continue;
+			}
+			if (isOversizedLogsError(err)) {
+				if (fromBlock === toBlock) throw new UnrecoverableLogsResponseSizeError(fromBlock, err);
+				adaptiveBlockWindow = max$1((toBlock - fromBlock) / 2n, MIN_BLOCK_WINDOW);
+				if (order === "asc") toBlock = min(fromBlock + adaptiveBlockWindow, upperBound);
+				else fromBlock = max$1(toBlock - adaptiveBlockWindow, lowerBound);
+				continue;
+			}
+			throw err;
+		}
+		streaming = order === "asc" ? toBlock < upperBound : fromBlock > lowerBound;
 		if (logs.length === 0 && !streaming) break;
 		if (logs.length === 0 && streaming) yield {
 			logs: [],
@@ -2397,17 +2473,19 @@ async function* streamLogs(parameters) {
 			logs: logBatch,
 			blockNumber: logBatch.length === maxBatchSize ? Number(logBatch[logBatch.length - 1]?.blockNumber) : order === "asc" ? Number(toBlock) : Number(fromBlock)
 		};
+		if (adaptiveBlockWindow < configuredBlockWindow) {
+			const expandedBlockWindow = adaptiveBlockWindow === 0n ? 1n : adaptiveBlockWindow * 2n;
+			adaptiveBlockWindow = min(expandedBlockWindow, configuredBlockWindow);
+		}
 		if (order === "asc") {
-			const upperBound = BigInt(blockNumberLte || latestBlock);
 			const nextFromBlock = min(BigInt(toBlock) + 1n, upperBound);
-			const nextToBlock = min(toBlock + BigInt(blockWindow) + 1n, upperBound);
+			const nextToBlock = min(toBlock + adaptiveBlockWindow + 1n, upperBound);
 			fromBlock = nextFromBlock;
 			toBlock = nextToBlock;
 		}
 		if (order === "desc") {
-			const lowerBound = BigInt(blockNumberGte || 0);
 			const nextToBlock = max$1(fromBlock - 1n, lowerBound);
-			const nextFromBlock = max$1(fromBlock - BigInt(blockWindow) - 1n, lowerBound);
+			const nextFromBlock = max$1(fromBlock - adaptiveBlockWindow - 1n, lowerBound);
 			toBlock = nextToBlock;
 			fromBlock = nextFromBlock;
 		}
@@ -2417,30 +2495,62 @@ async function* streamLogs(parameters) {
 		blockNumber: order === "asc" ? Number(toBlock) : Number(fromBlock)
 	};
 }
+const isBlockOutOfRangeError = (error) => {
+	let cause = error;
+	while (cause && typeof cause === "object") {
+		const candidate = cause;
+		if (typeof candidate.message === "string" && candidate.message.includes("BlockOutOfRangeError") || typeof candidate.details === "string" && candidate.details.includes("BlockOutOfRangeError")) return true;
+		cause = candidate.cause;
+	}
+	return false;
+};
 var InvalidBlockRangeError = class extends BaseError {
+	name = "Chain.InvalidBlockRangeError";
+	fromBlock;
+	toBlock;
 	constructor(fromBlock, toBlock) {
 		super(`Invalid block range while streaming data from chain. From block ${fromBlock} to block ${toBlock}.`);
-		_defineProperty(this, "name", "Chain.InvalidBlockRangeError");
+		this.fromBlock = fromBlock;
+		this.toBlock = toBlock;
 	}
 };
 var InvalidBlockWindowError = class extends BaseError {
+	name = "Chain.InvalidBlockWindowError";
 	constructor(blockWindow) {
 		super(`Invalid block window while streaming data from chain. Maximum is ${MAX_BLOCK_WINDOW}. Got ${blockWindow}.`);
-		_defineProperty(this, "name", "Chain.InvalidBlockWindowError");
 	}
 };
 var InvalidBatchSizeError = class extends BaseError {
+	name = "Chain.InvalidBatchSizeError";
 	constructor(maxBatchSize) {
 		super(`Invalid batch size while streaming data from chain. Maximum is ${MAX_BATCH_SIZE}. Got ${maxBatchSize}.`);
-		_defineProperty(this, "name", "Chain.InvalidBatchSizeError");
 	}
 };
 var MissingBlockNumberError = class extends BaseError {
+	name = "Chain.MissingBlockNumberError";
 	constructor() {
 		super("Missing block number when streaming data from chain in ascending order.");
-		_defineProperty(this, "name", "Chain.MissingBlockNumberError");
 	}
 };
+var UnrecoverableLogsResponseSizeError = class extends BaseError {
+	name = "Chain.UnrecoverableLogsResponseSizeError";
+	constructor(blockNumber, cause) {
+		const rootCause = cause instanceof Error ? cause : cause === void 0 ? void 0 : new Error(String(cause));
+		super(`Failed to stream logs because even a single-block query exceeded the RPC response size limit at block ${blockNumber}.`, { cause: rootCause });
+	}
+};
+function isOversizedLogsError(err) {
+	return oversizedLogsErrorPatterns.some((pattern) => collectErrorMessages(err).includes(pattern));
+}
+function collectErrorMessages(err) {
+	if (!(err instanceof Error)) return "";
+	const fragments = [err.message];
+	const candidate = err;
+	if (typeof candidate.details === "string") fragments.push(candidate.details);
+	if (typeof candidate.shortMessage === "string") fragments.push(candidate.shortMessage);
+	if (candidate.cause instanceof Error) fragments.push(collectErrorMessages(candidate.cause));
+	return fragments.join(" ").toLowerCase();
+}
 
 //#endregion
 //#region src/core/ChainRegistry.ts
@@ -2465,6 +2575,7 @@ var Random_exports = /* @__PURE__ */ __exportAll({
 	address: () => address,
 	bool: () => bool,
 	bytes: () => bytes,
+	createRng: () => createRng,
 	float: () => float,
 	hex: () => hex,
 	int: () => int,
@@ -2482,7 +2593,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;
@@ -2496,7 +2619,7 @@ const createSeededRng = (seed) => {
 */
 function withSeed(seed, fn) {
 	const previous = currentRng;
-	currentRng = createSeededRng(seed);
+	currentRng = createSeededRngFn(seed);
 	try {
 		return fn();
 	} finally {
@@ -2507,7 +2630,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).
@@ -2663,15 +2786,15 @@ function from$11(lltv) {
 	return BigInt(lltv * 10 ** 18);
 }
 var InvalidOptionError$1 = class extends BaseError {
+	name = "LLTV.InvalidOptionError";
 	constructor(input) {
 		super(`Invalid LLTV option. Input: "${input}". Accepted values are: ${Options.map((option) => `"${option}"`).join(", ")}.`);
-		_defineProperty(this, "name", "LLTV.InvalidOptionError");
 	}
 };
 var InvalidLLTVError = class extends BaseError {
+	name = "LLTV.InvalidLLTVError";
 	constructor(input) {
 		super(`Invalid LLTV. Input: "${input}". Accepted values are: ${LLTV_SCALED.map((option) => `"${option}"`).join(", ")}.`);
-		_defineProperty(this, "name", "LLTV.InvalidLLTVError");
 	}
 };
 const LLTVSchema = z$1.bigint({ coerce: true }).refine((lltv) => {
@@ -2703,6 +2826,10 @@ const abi$1 = [
 		type: "uint256",
 		name: "lltv"
 	},
+	{
+		type: "uint256",
+		name: "maxLif"
+	},
 	{
 		type: "address",
 		name: "oracle"
@@ -2711,7 +2838,8 @@ const abi$1 = [
 const CollateralSchema = z$1.object({
 	asset: z$1.string().transform(transformAddress),
 	oracle: z$1.string().transform(transformAddress),
-	lltv: LLTVSchema
+	lltv: LLTVSchema,
+	maxLif: z$1.bigint({ coerce: true }).min(0n).optional().default(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;
@@ -2729,6 +2857,7 @@ const from$10 = (parameters) => {
 	return {
 		asset: parameters.asset.toLowerCase(),
 		lltv: from$11(parameters.lltv),
+		maxLif: parameters.maxLif ?? 0n,
 		oracle: parameters.oracle.toLowerCase()
 	};
 };
@@ -2745,7 +2874,8 @@ function random$3() {
 	return from$10({
 		asset: address(),
 		oracle: address(),
-		lltv: .965
+		lltv: .965,
+		maxLif: 0n
 	});
 }
 
@@ -2806,9 +2936,9 @@ function convertToShares(parameters) {
 	return parameters.assets * (parameters.totalSupply + 10n ** BigInt(parameters.decimalsOffset)) / denominator;
 }
 var DenominatorIsZeroError = class extends BaseError {
+	name = "ERC4626.DenominatorIsZeroError";
 	constructor() {
 		super("Denominator is 0.");
-		_defineProperty(this, "name", "ERC4626.DenominatorIsZeroError");
 	}
 };
 
@@ -2876,9 +3006,9 @@ const MaturitySchema = z$1.number().int().refine((maturity) => {
 	}
 }, { error: (issue) => {
 	try {
-		return `The maturity is set to ${/* @__PURE__ */ new Date(issue.input * 1e3)}. It must fall on the allowed settlement cycles (Friday 15:00 UTC at the end of week/month/quarter).`;
+		return `The maturity is set to ${/* @__PURE__ */ new Date(issue.input * 1e3)}. It must be at 15:00:00 UTC.`;
 	} catch (_) {
-		return `The maturity is set to ${issue.input}. It must fall on the allowed settlement cycles (Friday 15:00 UTC at the end of week/month/quarter).`;
+		return `The maturity is set to ${issue.input}. It must be at 15:00:00 UTC.`;
 	}
 } }).transform((maturity) => maturity);
 let MaturityType = /* @__PURE__ */ function(MaturityType) {
@@ -2910,9 +3040,14 @@ function from$9(ts) {
 		throw new InvalidOptionError(ts);
 	}
 	if (typeof ts === "number" && ts > 0xe8d4a51000) throw new InvalidFormatError();
-	if (!Object.values(MaturityOptions).some((option) => option() === ts)) throw new InvalidDateError(ts);
+	if (!isAt15UTC(ts)) throw new InvalidDateError(ts);
 	return ts;
 }
+/** Checks whether a timestamp (in seconds) falls at exactly 15:00:00 UTC. */
+function isAt15UTC(ts) {
+	const date = /* @__PURE__ */ new Date(ts * 1e3);
+	return date.getUTCHours() === 15 && date.getUTCMinutes() === 0 && date.getUTCSeconds() === 0 && date.getUTCMilliseconds() === 0;
+}
 /** Returns the end of the current week (friday at 15:00:00 UTC) */
 const endOfWeek = () => fridayOfWeek(0);
 /** Returns the end of the next week (friday at 15:00:00 UTC) */
@@ -2965,21 +3100,21 @@ const lastFridayOfQuarter = (quartersAhead = 0) => {
 	return lastFridayOfMonth(now.getUTCFullYear() + Math.floor(quarterIndex / 4), quarterIndex % 4 * 3 + 2);
 };
 var InvalidFormatError = class extends BaseError {
+	name = "Maturity.InvalidFormatError";
 	constructor() {
 		super("Invalid maturity format. Maturity should be expressed in seconds.");
-		_defineProperty(this, "name", "Maturity.InvalidFormatError");
 	}
 };
 var InvalidDateError = class extends BaseError {
+	name = "Maturity.InvalidDateError";
 	constructor(input) {
-		super(`Invalid maturity date. Input: "${input}". Accepted values are: ${Object.values(MaturityOptions).map((option) => `"${option()}"`).join(", ")}.`);
-		_defineProperty(this, "name", "Maturity.InvalidDateError");
+		super(`Invalid maturity date. Input: "${input}". Maturity must be at 15:00:00 UTC.`);
 	}
 };
 var InvalidOptionError = class extends BaseError {
+	name = "Maturity.InvalidOptionError";
 	constructor(input) {
 		super(`Invalid maturity option. Input: "${input}". Accepted values are: ${Object.keys(MaturityOptions).map((option) => `"${option}"`).join(", ")}.`);
-		_defineProperty(this, "name", "Maturity.InvalidOptionError");
 	}
 };
 
@@ -3000,7 +3135,8 @@ var Obligation_exports = /* @__PURE__ */ __exportAll({
 const ObligationSchema = z$1.object({
 	loanToken: z$1.string().transform(transformAddress),
 	collaterals: CollateralsSchema,
-	maturity: MaturitySchema
+	maturity: MaturitySchema,
+	rcfThreshold: z$1.bigint({ coerce: true }).min(0n)
 });
 const abi = [
 	{
@@ -3015,6 +3151,10 @@ const abi = [
 	{
 		type: "uint256",
 		name: "maturity"
+	},
+	{
+		type: "uint256",
+		name: "rcfThreshold"
 	}
 ];
 const tupleAbi = [{
@@ -3040,6 +3180,7 @@ const tupleAbi = [{
 *     }),
 *   ],
 *   maturity: Maturity.from("end_of_next_quarter"),
+*   rcfThreshold: 0n,
 * });
 * ```
 */
@@ -3052,7 +3193,8 @@ function from$8(parameters) {
 		return {
 			loanToken: parsedObligation.loanToken.toLowerCase(),
 			collaterals: parsedObligation.collaterals.sort((a, b) => a.asset.localeCompare(b.asset)),
-			maturity: parsedObligation.maturity
+			maturity: parsedObligation.maturity,
+			rcfThreshold: parsedObligation.rcfThreshold
 		};
 	} catch (error) {
 		throw new InvalidObligationError(error);
@@ -3069,7 +3211,7 @@ function fromSnakeCase$2(input) {
 }
 /**
 * Calculates a canonical key for an obligation payload.
-* The key is computed as keccak256(abi.encode(loanToken, collaterals, maturity)).
+* The key is computed as keccak256(abi.encode(loanToken, collaterals, maturity, 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}
@@ -3093,9 +3235,11 @@ function key(parameters) {
 		parameters.collaterals.map((c) => ({
 			token: c.asset.toLowerCase(),
 			lltv: c.lltv,
+			maxLif: c.maxLif ?? 0n,
 			oracle: c.oracle.toLowerCase()
 		})),
-		BigInt(parameters.maturity)
+		BigInt(parameters.maturity),
+		parameters.rcfThreshold
 	]));
 }
 /**
@@ -3111,7 +3255,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
 	});
 }
 /**
@@ -3125,19 +3270,20 @@ 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 {
+	name = "Obligation.InvalidObligationError";
 	constructor(error) {
 		super("Invalid obligation.", { cause: error });
-		_defineProperty(this, "name", "Obligation.InvalidObligationError");
 	}
 };
 var CollateralsAreNotSortedError = class extends BaseError {
+	name = "Obligation.CollateralsAreNotSortedError";
 	constructor() {
 		super("Collaterals are not sorted alphabetically by address.");
-		_defineProperty(this, "name", "Obligation.CollateralsAreNotSortedError");
 	}
 };
 
@@ -3147,39 +3293,42 @@ var Id_exports = /* @__PURE__ */ __exportAll({
 	creationCode: () => creationCode,
 	toId: () => toId
 });
-const CREATION_CODE_PREFIX = "0x603f380380603f5f395ff3";
+const CREATION_CODE_PREFIX = "0x600b380380600b5f395ff3";
 /**
 * Builds the same creation code as `IdLib.creationCode` in Solidity.
 *
-* Layout: `prefix (11 bytes) + chainId (32 bytes) + morphoV2 (20 bytes) + abi.encode(obligation)`.
+* Layout: `prefix (11 bytes) + abi.encode(obligation)`.
 *
 * @param parameters - {@link creationCode.Parameters}
 * @returns The CREATE2 init code bytes. {@link creationCode.ReturnType}
 */
 function creationCode(parameters) {
-	const encodedObligation = encodeAbiParameters(tupleAbi, [{
+	return concatHex([CREATION_CODE_PREFIX, encodeAbiParameters(tupleAbi, [{
 		loanToken: parameters.obligation.loanToken.toLowerCase(),
 		collaterals: parameters.obligation.collaterals.map((collateral) => ({
 			token: collateral.asset.toLowerCase(),
 			lltv: collateral.lltv,
+			maxLif: collateral.maxLif ?? 0n,
 			oracle: collateral.oracle.toLowerCase()
 		})),
-		maturity: BigInt(parameters.obligation.maturity)
-	}]);
-	return concatHex([
-		CREATION_CODE_PREFIX,
-		numberToHex(BigInt(parameters.chainId), { size: 32 }),
-		parameters.morphoV2.toLowerCase(),
-		encodedObligation
-	]);
+		maturity: BigInt(parameters.obligation.maturity),
+		rcfThreshold: parameters.obligation.rcfThreshold
+	}])]);
 }
 /**
-* Computes the same id as `IdLib.toId` in Solidity.
+* Computes the same id as `IdLib.toId` in Solidity using the CREATE2 preimage:
+* `keccak256(0xff ++ morphoV2 ++ chainId ++ keccak256(creationCode))`.
+*
 * @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 keccak256(creationCode(parameters));
+	return keccak256(concatHex([
+		"0xff",
+		parameters.morphoV2.toLowerCase(),
+		numberToHex(BigInt(parameters.chainId), { size: 32 }),
+		keccak256(creationCode(parameters))
+	]));
 }
 
 //#endregion
@@ -3269,7 +3418,6 @@ var Offer_exports = /* @__PURE__ */ __exportAll({
 	fromSnakeCase: () => fromSnakeCase$1,
 	hash: () => hash,
 	liquidateEvent: () => liquidateEvent,
-	obligationId: () => obligationId,
 	random: () => random$1,
 	repayEvent: () => repayEvent,
 	serialize: () => serialize,
@@ -3288,11 +3436,10 @@ 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),
 		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([
@@ -3312,7 +3459,8 @@ const OfferSchema = () => {
 			address: z$1.string().transform(transformAddress),
 			data: z$1.string().transform(transformHex)
 		}),
-		receiverIfMakerIsSeller: z$1.string().transform(transformAddress)
+		receiverIfMakerIsSeller: z$1.string().transform(transformAddress),
+		exitOnly: z$1.boolean().optional().default(false)
 	}).refine((data) => data.start < data.expiry, {
 		message: "start must be before expiry",
 		path: ["start"]
@@ -3364,11 +3512,10 @@ function toSnakeCase(offer) {
 */
 const serialize = (offer) => ({
 	maker: offer.maker,
-	assets: offer.assets.toString(),
 	obligationUnits: offer.obligationUnits.toString(),
-	obligationShares: offer.obligationShares.toString(),
 	tick: offer.tick,
 	maturity: Number(offer.maturity),
+	rcfThreshold: offer.rcfThreshold.toString(),
 	expiry: Number(offer.expiry),
 	start: Number(offer.start),
 	group: offer.group,
@@ -3378,13 +3525,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)
 });
 /**
@@ -3421,7 +3570,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 obligationUnitsScaled = config?.obligationUnits ?? amountBase * unit;
 	const emptyCallback = {
 		address: zeroAddress,
 		data: "0x"
@@ -3429,11 +3578,10 @@ function random$1(config) {
 	const maker = config?.maker ?? address();
 	return from$7({
 		maker,
-		assets: assetsScaled,
-		obligationUnits: config?.obligationUnits ?? 0n,
-		obligationShares: config?.obligationShares ?? 0n,
+		obligationUnits: obligationUnitsScaled,
 		tick,
 		maturity,
+		rcfThreshold: config?.rcfThreshold ?? 0n,
 		expiry: config?.expiry ?? maturity - 1,
 		start: config?.start ?? maturity - 10,
 		group: config?.group ?? hex(32),
@@ -3445,7 +3593,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) => {
@@ -3472,124 +3621,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 32-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 obligationUnits;
+*     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: "obligationUnits",
+			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 ?? 0n,
+				oracle: c.oracle
+			})),
+			maturity: BigInt(offer.maturity),
+			rcfThreshold: offer.rcfThreshold
+		},
+		buy: offer.buy,
+		maker: offer.maker,
+		obligationUnits: offer.obligationUnits,
+		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;
@@ -3598,31 +3773,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,
+		obligationUnits: s.obligationUnits,
+		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
 	});
 }
 /**
@@ -3639,7 +3816,7 @@ const takeEvent = {
 			internalType: "address"
 		},
 		{
-			name: "id",
+			name: "id_",
 			type: "bytes32",
 			indexed: true,
 			internalType: "bytes32"
@@ -3680,24 +3857,6 @@ const takeEvent = {
 			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",
@@ -3715,19 +3874,31 @@ const takeEvent = {
 			type: "uint256",
 			indexed: false,
 			internalType: "uint256"
-		}
-	],
-	anonymous: false
+		},
+		{
+			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"
@@ -3761,7 +3932,7 @@ const repayEvent = {
 			internalType: "address"
 		},
 		{
-			name: "id",
+			name: "id_",
 			type: "bytes32",
 			indexed: true,
 			internalType: "bytes32"
@@ -3795,33 +3966,28 @@ const liquidateEvent = {
 			internalType: "address"
 		},
 		{
-			name: "id",
+			name: "id_",
 			type: "bytes32",
 			indexed: true,
 			internalType: "bytes32"
 		},
 		{
-			name: "seizures",
-			type: "tuple[]",
+			name: "collateralIndex",
+			type: "uint256",
 			indexed: false,
-			internalType: "struct IMorphoV2.Seizure[]",
-			components: [
-				{
-					name: "collateralIndex",
-					type: "uint256",
-					internalType: "uint256"
-				},
-				{
-					name: "repaid",
-					type: "uint256",
-					internalType: "uint256"
-				},
-				{
-					name: "seized",
-					type: "uint256",
-					internalType: "uint256"
-				}
-			]
+			internalType: "uint256"
+		},
+		{
+			name: "seizedAssets",
+			type: "uint256",
+			indexed: false,
+			internalType: "uint256"
+		},
+		{
+			name: "repaidUnits",
+			type: "uint256",
+			indexed: false,
+			internalType: "uint256"
 		},
 		{
 			name: "borrower",
@@ -3830,13 +3996,13 @@ const liquidateEvent = {
 			internalType: "address"
 		},
 		{
-			name: "totalRepaid",
+			name: "badDebt",
 			type: "uint256",
 			indexed: false,
 			internalType: "uint256"
 		},
 		{
-			name: "badDebt",
+			name: "latestLossIndex",
 			type: "uint256",
 			indexed: false,
 			internalType: "uint256"
@@ -3858,7 +4024,7 @@ const supplyCollateralEvent = {
 			internalType: "address"
 		},
 		{
-			name: "id",
+			name: "id_",
 			type: "bytes32",
 			indexed: true,
 			internalType: "bytes32"
@@ -3898,7 +4064,7 @@ const withdrawCollateralEvent = {
 			internalType: "address"
 		},
 		{
-			name: "id",
+			name: "id_",
 			type: "bytes32",
 			indexed: true,
 			internalType: "bytes32"
@@ -3931,9 +4097,9 @@ const withdrawCollateralEvent = {
 	anonymous: false
 };
 var InvalidOfferError = class InvalidOfferError extends BaseError {
+	name = "Offer.InvalidOfferError";
 	constructor(error) {
 		super("Invalid offer.", { cause: error });
-		_defineProperty(this, "name", "Offer.InvalidOfferError");
 	}
 	/**
 	* Formats ZodError issues into a human-readable string with line breaks.
@@ -4146,9 +4312,9 @@ function random() {
 	});
 }
 var InvalidQuoteError = class extends BaseError {
+	name = "Quote.InvalidQuoteError";
 	constructor(error) {
 		super("Invalid quote.", { cause: error });
-		_defineProperty(this, "name", "Quote.InvalidQuoteError");
 	}
 };
 function sideFromTick(side) {
@@ -4174,7 +4340,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,
@@ -4182,21 +4348,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);
 	}
@@ -4215,7 +4382,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];
@@ -4255,7 +4424,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;
@@ -4266,44 +4435,35 @@ 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). */
 var InvalidFeeError = class extends BaseError {
+	name = "TradingFee.InvalidFeeError";
 	constructor(fee, index) {
 		super(`Invalid fee at index ${index}: ${fee}. Fee must be between 0 and ${WAD} (WAD).`);
-		_defineProperty(this, "name", "TradingFee.InvalidFeeError");
 	}
 };
-/** 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.`);
-		_defineProperty(this, "name", "TradingFee.InvalidFeesLengthError");
+		super(`Invalid fees length: ${length}. Expected exactly 7 fee values.`);
 	}
 };
 
@@ -4341,9 +4501,12 @@ 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,
+	VERSION: () => VERSION$1,
 	decode: () => decode,
 	encode: () => encode,
 	encodeUnsigned: () => encodeUnsigned,
@@ -4352,7 +4515,16 @@ var Tree_exports = /* @__PURE__ */ __exportAll({
 	signatureDomain: () => signatureDomain,
 	signatureTypes: () => signatureTypes
 });
-const VERSION = 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)).
 */
@@ -4369,29 +4541,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 {
@@ -4406,7 +4632,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}
@@ -4415,7 +4641,7 @@ const proofs = (tree) => {
 	return tree.offers.map((offer) => {
 		return {
 			offer,
-			path: tree.getProof([hash(offer)])
+			path: tree.getProof(hash(offer))
 		};
 	});
 };
@@ -4546,16 +4772,17 @@ const encodeUnsigned = (tree) => {
 	return bytesToHex(encodeUnsignedBytes(tree));
 };
 const validateTreeForEncoding = (tree) => {
-	if (VERSION > 255) throw new EncodeError(`version overflow: ${VERSION} exceeds 255`);
+	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);
-	encoded[0] = VERSION;
+	const encoded = new Uint8Array(1 + compressed.length + ROOT_BYTES);
+	encoded[0] = VERSION$1;
 	encoded.set(compressed, 1);
 	encoded.set(rootBytes, 1 + compressed.length);
 	return encoded;
@@ -4567,10 +4794,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
@@ -4587,33 +4815,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 & 255)) throw new DecodeError(`invalid version: expected ${VERSION}, got ${version ?? 0}`);
-	const signature = bytesToHex(bytes.slice(-65));
-	const root = bytesToHex(bytes.slice(-97, -65));
-	assertHex(root, 32, "root");
-	assertHex(signature, 65, "signature");
+	if (version !== (VERSION$1 & 255)) throw new DecodeError(`invalid version: expected ${VERSION$1}, got ${version ?? 0}`);
+	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,
@@ -4626,9 +4841,9 @@ const decode = async (encoded, domain) => {
 * Indicates structural issues with the tree (missing offers, inconsistent state).
 */
 var TreeError = class extends BaseError {
+	name = "Tree.TreeError";
 	constructor(reason) {
 		super(`Tree error: ${reason}`);
-		_defineProperty(this, "name", "Tree.TreeError");
 	}
 };
 /**
@@ -4636,9 +4851,9 @@ var TreeError = class extends BaseError {
 * Indicates validation failures (signature, root mismatch, mixed makers).
 */
 var EncodeError = class extends BaseError {
+	name = "Tree.EncodeError";
 	constructor(reason) {
 		super(`Failed to encode tree: ${reason}`);
-		_defineProperty(this, "name", "Tree.EncodeError");
 	}
 };
 /**
@@ -4646,18 +4861,18 @@ var EncodeError = class extends BaseError {
 * Indicates payload corruption, version mismatch, or validation failures.
 */
 var DecodeError = class extends BaseError {
+	name = "Tree.DecodeError";
 	constructor(reason) {
 		super(`Failed to decode tree: ${reason}`);
-		_defineProperty(this, "name", "Tree.DecodeError");
 	}
 };
 /**
 * Error thrown when an invalid signature domain is supplied.
 */
 var SignatureDomainError = class extends BaseError {
+	name = "Tree.SignatureDomainError";
 	constructor(reason) {
 		super(`Invalid signature domain: ${reason}`);
-		_defineProperty(this, "name", "Tree.SignatureDomainError");
 	}
 };
 
@@ -4732,11 +4947,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,
 				tick: offerData.tick,
 				maturity: from$9(offerData.obligation.maturity),
+				rcf_threshold: offerData.obligation.rcf_threshold,
 				expiry: offerData.expiry,
 				start: offerData.start,
 				group: offerData.group,
@@ -4746,13 +4960,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),
@@ -4793,9 +5009,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,
@@ -4815,36 +5033,51 @@ async function getObligations(apiClient, parameters) {
 	};
 }
 var InvalidUrlError = class extends BaseError {
+	name = "Router.InvalidUrlError";
 	constructor(url) {
 		super(`URL "${url}" is not http/https.`);
-		_defineProperty(this, "name", "Router.InvalidUrlError");
 	}
 };
 var HttpUnauthorizedError = class extends BaseError {
+	name = "Router.HttpUnauthorizedError";
 	constructor() {
 		super("Unauthorized.", { metaMessages: ["Ensure that an API key is provided."] });
-		_defineProperty(this, "name", "Router.HttpUnauthorizedError");
 	}
 };
 var HttpForbiddenError = class extends BaseError {
+	name = "Router.HttpForbiddenError";
 	constructor() {
 		super("Forbidden.", { metaMessages: ["Ensure that the API key is valid."] });
-		_defineProperty(this, "name", "Router.HttpForbiddenError");
 	}
 };
 var HttpRateLimitError = class extends BaseError {
+	name = "Router.HttpRateLimitError";
 	constructor() {
 		super("Rate limit exceeded.", { metaMessages: ["The number of allowed requests has been exceeded. You must wait for the rate limit to reset."] });
-		_defineProperty(this, "name", "Router.HttpRateLimitError");
 	}
 };
 var HttpGetApiFailedError = class extends BaseError {
+	name = "Router.HttpGetApiFailedError";
 	constructor(message, { details } = {}) {
 		super(message, { metaMessages: [details] });
-		_defineProperty(this, "name", "Router.HttpGetApiFailedError");
 	}
 };
 
+//#endregion
+//#region src/observability/TraceHeaders.ts
+/**
+* Inject active trace context headers into outgoing HTTP headers.
+* @param headers - Existing headers for the outgoing request.
+* @returns Headers enriched with active trace context.
+*/
+function withActiveTraceHeaders(headers) {
+	const enrichedHeaders = new Headers(headers);
+	const carrier = {};
+	propagation.inject(context.active(), carrier);
+	for (const [key, value] of Object.entries(carrier)) enrichedHeaders.set(key, value);
+	return enrichedHeaders;
+}
+
 //#endregion
 //#region src/gatekeeper/Client.ts
 var Client_exports = /* @__PURE__ */ __exportAll({ createHttpClient: () => createHttpClient });
@@ -4865,7 +5098,7 @@ function createHttpClient(config) {
 		try {
 			return await fetchFn(`${baseUrl}${path}`, {
 				...init,
-				headers: mergeHeaders(baseHeaders, init.headers),
+				headers: withActiveTraceHeaders(mergeHeaders(baseHeaders, init.headers)),
 				signal: controller.signal
 			});
 		} finally {
@@ -5117,7 +5350,7 @@ const collateralAssets = {
 		"0x7f39C581F595B53c5cb19bD0b3f8dA6c935E2Ca0"
 	]
 };
-const oracles = {
+const oracles$1 = {
 	[ChainId.ETHEREUM.toString()]: [
 		"0xDddd770BADd886dF3864029e4B377B5F6a2B6b83",
 		"0x9CB3f4276bcD149b3668e1a645a964bC12877b89",
@@ -5139,6 +5372,7 @@ const oracles = {
 	],
 	[ChainId["ETHEREUM-VIRTUAL-TESTNET"].toString()]: [
 		"0xDddd770BADd886dF3864029e4B377B5F6a2B6b83",
+		"0xEeee770BADd886dF3864029e4B377B5F6a2B6b83",
 		"0x9CB3f4276bcD149b3668e1a645a964bC12877b89",
 		"0x48F7E36EB6B826B2dF4B2E630B62Cd25e89E40e2",
 		"0x6Eb9F4128CeBc8B885A4d8562Db1Addf097f7348",
@@ -5147,6 +5381,7 @@ const oracles = {
 	],
 	[ChainId.ANVIL.toString()]: [
 		"0xDddd770BADd886dF3864029e4B377B5F6a2B6b83",
+		"0xEeee770BADd886dF3864029e4B377B5F6a2B6b83",
 		"0x9CB3f4276bcD149b3668e1a645a964bC12877b89",
 		"0x48F7E36EB6B826B2dF4B2E630B62Cd25e89E40e2",
 		"0x6Eb9F4128CeBc8B885A4d8562Db1Addf097f7348",
@@ -5157,30 +5392,698 @@ const oracles = {
 const configs = {
 	ethereum: {
 		callbacks: [{ type: Type$1.BuyWithEmptyCallback }, { type: Type$1.SellWithEmptyCallback }],
-		maturities: [MaturityType.EndOfWeek, MaturityType.EndOfNextWeek]
+		maturities: [MaturityType.EndOfWeek, MaturityType.EndOfNextWeek],
+		minDuration: 10
 	},
 	base: {
 		callbacks: [{ type: Type$1.BuyWithEmptyCallback }, { type: Type$1.SellWithEmptyCallback }],
-		maturities: [MaturityType.EndOfWeek, MaturityType.EndOfNextWeek]
+		maturities: [MaturityType.EndOfWeek, MaturityType.EndOfNextWeek],
+		minDuration: 10
 	},
 	"ethereum-virtual-testnet": {
 		callbacks: [{ type: Type$1.BuyWithEmptyCallback }, { type: Type$1.SellWithEmptyCallback }],
-		maturities: [MaturityType.EndOfWeek, MaturityType.EndOfNextWeek]
+		maturities: [MaturityType.EndOfWeek, MaturityType.EndOfNextWeek],
+		minDuration: 10
 	},
 	anvil: {
 		callbacks: [{ type: Type$1.BuyWithEmptyCallback }, { type: Type$1.SellWithEmptyCallback }],
-		maturities: [MaturityType.EndOfWeek, MaturityType.EndOfNextWeek]
+		maturities: [MaturityType.EndOfWeek, MaturityType.EndOfNextWeek],
+		minDuration: 10
+	}
+};
+
+//#endregion
+//#region src/utils/retry.ts
+const retry = async (fn, attempts = 3, delayMs = 50) => {
+	let lastErr;
+	for (let i = 0; i < attempts; i++) try {
+		return await fn();
+	} catch (err) {
+		lastErr = err;
+		if (i < attempts - 1) await new Promise((r) => setTimeout(r, delayMs));
+	}
+	throw lastErr;
+};
+
+//#endregion
+//#region src/utils/batchMulticall.ts
+/**
+* Helper function to execute multicall in batches with retry logic.
+* Abstracts the common pattern of batching calls, retrying, and collecting results.
+*
+* @param parameters - Configuration for batched multicall
+* @returns Promise resolving to flattened array of results
+*/
+async function batchMulticall(parameters) {
+	const { client, calls, batchSize, retryAttempts, retryDelayMs, blockNumber } = parameters;
+	const results = [];
+	for (const callsBatch of batch$1(calls, batchSize)) {
+		const batchResults = await retry(() => multicall(client, {
+			allowFailure: false,
+			contracts: callsBatch,
+			...blockNumber ? { blockNumber } : {}
+		}), retryAttempts, retryDelayMs);
+		results.push(...batchResults);
 	}
+	return results;
+}
+
+//#endregion
+//#region src/utils/Group.ts
+var Group_exports = /* @__PURE__ */ __exportAll({ fromNumber: () => fromNumber });
+/**
+* Creates a bytes32 group identifier from a number.
+* @param n - A non-negative integer.
+* @throws {Error} If n is negative or not an integer.
+*/
+const fromNumber = (n) => {
+	if (!Number.isInteger(n)) throw new Error(`Group.fromNumber: expected integer, got ${n}`);
+	if (n < 0) throw new Error(`Group.fromNumber: expected non-negative, got ${n}`);
+	return pad(`0x${n.toString(16)}`, { size: 32 });
+};
+
+//#endregion
+//#region src/utils/lazy.ts
+/**
+* Transform a polling function into an async generator.
+* @param fn - The polling function to transform.
+* @returns An async generator.
+*/
+function lazy(pollFn) {
+	return () => (async function* () {
+		let active = true;
+		let resolveNext = null;
+		const queue = [];
+		const wait = () => new Promise((resolve) => {
+			resolveNext = resolve;
+		});
+		const emit = (item) => {
+			queue.push(item);
+			resolveNext?.();
+			resolveNext = null;
+		};
+		let unpoll = null;
+		const stop = () => {
+			active = false;
+			unpoll?.();
+			resolveNext?.();
+			resolveNext = null;
+		};
+		unpoll = pollFn(emit, { stop });
+		try {
+			while (active) {
+				if (queue.length === 0) await wait();
+				while (queue.length > 0 && active) yield queue.shift();
+			}
+		} finally {
+			stop();
+		}
+	})();
+}
+
+//#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) {
+	return new Promise((res) => setTimeout(res, time));
+}
+
+//#endregion
+//#region src/utils/poll.ts
+/**
+* Polls a function at a specified interval.
+* Inspired by https://github.com/wevm/viem/blob/845994d20275d08ff892018e237a4b599eeefb6a/src/utils/poll.ts
+*/
+function poll(fn, { interval }) {
+	let active = true;
+	const unwatch = () => active = false;
+	const watch = async () => {
+		while (active) {
+			const delay = await interval();
+			if (!active) break;
+			await wait(delay);
+			if (!active) break;
+			await fn({ unpoll: unwatch });
+		}
+	};
+	watch();
+	return unwatch;
+}
+
+//#endregion
+//#region src/utils/time.ts
+var time_exports = /* @__PURE__ */ __exportAll({
+	max: () => max,
+	now: () => now
+});
+function now() {
+	return Math.floor(Date.now() / 1e3);
+}
+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({
+	BaseError: () => BaseError,
+	Group: () => Group_exports,
+	Random: () => Random_exports,
+	ReorgError: () => ReorgError,
+	Time: () => time_exports,
+	atMostOneNonZero: () => atMostOneNonZero,
+	batch: () => batch$1,
+	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.15";
+
+//#endregion
+//#region src/database/drizzle/schema.ts
+const s = pgSchema(VERSION);
+var EnumTableName = /* @__PURE__ */ function(EnumTableName) {
+	EnumTableName["OBLIGATIONS"] = "obligations";
+	EnumTableName["OBLIGATION_ID_KEYS"] = "obligation_id_keys";
+	EnumTableName["GROUPS"] = "groups";
+	EnumTableName["CONSUMED_EVENTS"] = "consumed_events";
+	EnumTableName["OBLIGATION_COLLATERALS_V2"] = "obligation_collaterals_v2";
+	EnumTableName["ORACLES"] = "oracles";
+	EnumTableName["OFFERS"] = "offers";
+	EnumTableName["OFFERS_CALLBACKS"] = "offers_callbacks";
+	EnumTableName["CALLBACKS"] = "callbacks";
+	EnumTableName["POSITIONS"] = "positions";
+	EnumTableName["TRANSFERS"] = "transfers";
+	EnumTableName["VALIDATIONS"] = "validations";
+	EnumTableName["COLLECTORS"] = "collectors";
+	EnumTableName["CHAINS"] = "chains";
+	EnumTableName["PENDING_LINKS"] = "pending_links";
+	EnumTableName["LOTS"] = "lots";
+	EnumTableName["LOTS_POSITIONS"] = "lots_positions";
+	EnumTableName["OFFSETS"] = "offsets";
+	EnumTableName["TREES"] = "trees";
+	EnumTableName["MERKLE_PATHS"] = "merkle_paths";
+	return EnumTableName;
+}(EnumTableName || {});
+const TABLE_NAMES = Object.values(EnumTableName);
+const VERSIONED_TABLE_NAMES = TABLE_NAMES.map((table) => `"${VERSION}"."${table}"`);
+const obligations = s.table(EnumTableName.OBLIGATIONS, {
+	obligationKey: varchar("obligation_key", { length: 66 }).primaryKey(),
+	loanToken: varchar("loan_token", { length: 42 }).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: 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()
+}, (table) => [index("obligation_id_keys_obligation_key_idx").on(table.obligationKey), index("obligation_id_keys_chain_id_idx").on(table.chainId)]);
+const groups = s.table(EnumTableName.GROUPS, {
+	chainId: bigint("chain_id", { mode: "number" }).$type().notNull(),
+	maker: varchar("maker", { length: 42 }).notNull(),
+	group: varchar("group", { length: 66 }).notNull(),
+	consumed: numeric("consumed", {
+		precision: 78,
+		scale: 0
+	}).notNull(),
+	blockNumber: bigint("block_number", { mode: "number" }).notNull(),
+	updatedAt: timestamp("updated_at").defaultNow().notNull()
+}, (table) => [primaryKey({
+	columns: [
+		table.chainId,
+		table.maker,
+		table.group
+	],
+	name: "groups_pk"
+})]);
+const consumedEvents = s.table(EnumTableName.CONSUMED_EVENTS, {
+	eventId: varchar("event_id", { length: 128 }).primaryKey(),
+	chainId: bigint("chain_id", { mode: "number" }).$type().notNull(),
+	maker: varchar("maker", { length: 42 }).notNull(),
+	group: varchar("group", { length: 66 }).notNull(),
+	amount: numeric("amount", {
+		precision: 78,
+		scale: 0
+	}).notNull(),
+	blockNumber: bigint("block_number", { mode: "number" }).notNull(),
+	createdAt: timestamp("created_at").defaultNow().notNull()
+}, (t) => [
+	foreignKey({
+		columns: [
+			t.chainId,
+			t.maker,
+			t.group
+		],
+		foreignColumns: [
+			groups.chainId,
+			groups.maker,
+			groups.group
+		],
+		name: "consumed_events_groups_fk"
+	}).onDelete("cascade"),
+	index("consumed_events_group_idx").on(t.chainId, t.maker, t.group),
+	index("consumed_events_block_number_idx").on(t.blockNumber)
+]);
+const obligationCollateralsV2 = s.table(EnumTableName.OBLIGATION_COLLATERALS_V2, {
+	obligationKey: varchar("obligation_key", { length: 66 }).notNull().references(() => obligations.obligationKey, { onDelete: "cascade" }),
+	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"
+})]);
+const oracles = s.table(EnumTableName.ORACLES, {
+	chainId: bigint("chain_id", { mode: "number" }).$type().notNull(),
+	address: varchar("address", { length: 42 }).notNull(),
+	price: numeric("price", {
+		precision: 78,
+		scale: 0
+	}),
+	blockNumber: bigint("block_number", { mode: "number" }).notNull(),
+	updatedAt: timestamp("updated_at").defaultNow().notNull()
+}, (table) => [primaryKey({
+	columns: [table.chainId, table.address],
+	name: "oracles_pk"
+})]);
+const offers = s.table(EnumTableName.OFFERS, {
+	hash: varchar("hash", { length: 66 }).notNull(),
+	obligationId: varchar("obligation_id", { length: 66 }).notNull().references(() => obligationIdKeys.obligationId, { onDelete: "cascade" }),
+	obligationUnits: numeric("obligation_units", {
+		precision: 78,
+		scale: 0
+	}).notNull().default("0"),
+	tick: integer("tick").notNull(),
+	maturity: integer("maturity").notNull(),
+	expiry: integer("expiry").notNull(),
+	start: integer("start").notNull(),
+	groupChainId: bigint("group_chain_id", { mode: "number" }).$type().notNull(),
+	groupMaker: varchar("group_maker", { length: 42 }).notNull(),
+	group: varchar("group_group", { length: 66 }).notNull(),
+	session: varchar("session", { length: 66 }).notNull(),
+	buy: boolean("buy").notNull(),
+	callbackAddress: varchar("callback_address", { length: 42 }).notNull(),
+	callbackData: text("callback_data").notNull(),
+	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) => [
+	primaryKey({
+		columns: [table.hash, table.obligationId],
+		name: "offers_pk"
+	}),
+	foreignKey({
+		columns: [
+			table.groupChainId,
+			table.groupMaker,
+			table.group
+		],
+		foreignColumns: [
+			groups.chainId,
+			groups.maker,
+			groups.group
+		],
+		name: "offers_groups_fk"
+	}).onDelete("cascade"),
+	index("offers_group_and_hash_idx").on(table.groupChainId, table.groupMaker, table.group, table.hash),
+	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)
+]);
+const offersCallbacks = s.table(EnumTableName.OFFERS_CALLBACKS, {
+	offerHash: varchar("offer_hash", { length: 66 }).notNull(),
+	obligationId: varchar("obligation_id", { length: 66 }).notNull(),
+	callbackId: varchar("callback_id", { length: 66 })
+}, (table) => [foreignKey({
+	columns: [table.offerHash, table.obligationId],
+	foreignColumns: [offers.hash, offers.obligationId],
+	name: "offers_callbacks_offer_fk"
+}).onDelete("cascade"), primaryKey({
+	columns: [
+		table.offerHash,
+		table.obligationId,
+		table.callbackId
+	],
+	name: "offers_callbacks_pk"
+})]);
+const CallbackTypes = s.enum("callback_type", Object.values(CallbackType));
+const callbacks = s.table(EnumTableName.CALLBACKS, {
+	id: varchar("id", { length: 66 }).primaryKey(),
+	positionChainId: bigint("position_chain_id", { mode: "number" }).$type().notNull(),
+	positionContract: varchar("position_contract", { length: 66 }).notNull(),
+	positionUser: varchar("position_user", { length: 42 }).notNull(),
+	positionTypeId: integer("position_type_id").notNull().references(() => positionTypes.id, { onDelete: "no action" }),
+	type: CallbackTypes("type").notNull()
+});
+const lotsPositions = s.table(EnumTableName.LOTS_POSITIONS, {
+	chainId: bigint("chain_id", { mode: "number" }).$type().notNull(),
+	contract: varchar("contract", { length: 66 }).notNull(),
+	user: varchar("user", { length: 42 }).notNull(),
+	positionTypeId: integer("position_type_id").notNull().references(() => positionTypes.id, { onDelete: "no action" })
+}, (table) => [primaryKey({
+	columns: [
+		table.chainId,
+		table.contract,
+		table.user
+	],
+	name: "lots_positions_pk"
+})]);
+const lots = s.table(EnumTableName.LOTS, {
+	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: 66 }).notNull(),
+	lower: numeric("lower", {
+		precision: 78,
+		scale: 0
+	}).notNull(),
+	upper: numeric("upper", {
+		precision: 78,
+		scale: 0
+	}).notNull()
+}, (table) => [
+	primaryKey({
+		columns: [
+			table.chainId,
+			table.user,
+			table.contract,
+			table.group,
+			table.obligationId
+		],
+		name: "lots_pk"
+	}),
+	foreignKey({
+		columns: [
+			table.chainId,
+			table.contract,
+			table.user
+		],
+		foreignColumns: [
+			lotsPositions.chainId,
+			lotsPositions.contract,
+			lotsPositions.user
+		],
+		name: "lots_lots_positions_fk"
+	}).onDelete("cascade"),
+	foreignKey({
+		columns: [
+			table.chainId,
+			table.user,
+			table.group
+		],
+		foreignColumns: [
+			groups.chainId,
+			groups.maker,
+			groups.group
+		],
+		name: "lots_groups_fk"
+	}).onDelete("cascade"),
+	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: 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"),
+	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(),
+	type: PositionTypes("type").notNull()
+});
+const positions = s.table(EnumTableName.POSITIONS, {
+	chainId: bigint("chain_id", { mode: "number" }).$type().notNull(),
+	contract: varchar("contract", { length: 66 }).notNull(),
+	user: varchar("user", { length: 42 }).notNull(),
+	positionTypeId: integer("position_type_id").notNull().references(() => positionTypes.id, { onDelete: "no action" }),
+	balance: numeric("balance", {
+		precision: 78,
+		scale: 0
+	}),
+	asset: varchar("asset", { length: 42 }).notNull(),
+	blockNumber: bigint("block_number", { mode: "number" }).notNull(),
+	updatedAt: timestamp("updated_at").defaultNow().notNull()
+}, (table) => [primaryKey({
+	columns: [
+		table.chainId,
+		table.contract,
+		table.user,
+		table.positionTypeId,
+		table.asset
+	],
+	name: "positions_pk"
+})]);
+const transfers = s.table(EnumTableName.TRANSFERS, {
+	eventId: varchar("event_id", { length: 128 }).primaryKey(),
+	chainId: bigint("chain_id", { mode: "number" }).$type().notNull(),
+	contract: varchar("contract", { length: 66 }).notNull(),
+	from: varchar("from", { length: 42 }).notNull(),
+	to: varchar("to", { length: 42 }).notNull(),
+	value: numeric("value", {
+		precision: 78,
+		scale: 0
+	}).notNull(),
+	positionTypeId: integer("position_type_id").notNull().references(() => positionTypes.id, { onDelete: "no action" }),
+	asset: varchar("asset", { length: 42 }).notNull(),
+	blockNumber: bigint("block_number", { mode: "number" }).notNull(),
+	createdAt: timestamp("created_at").defaultNow().notNull()
+}, (table) => [
+	foreignKey({
+		columns: [
+			table.chainId,
+			table.contract,
+			table.from,
+			table.positionTypeId,
+			table.asset
+		],
+		foreignColumns: [
+			positions.chainId,
+			positions.contract,
+			positions.user,
+			positions.positionTypeId,
+			positions.asset
+		],
+		name: "transfers_positions_from_fk"
+	}).onDelete("cascade"),
+	foreignKey({
+		columns: [
+			table.chainId,
+			table.contract,
+			table.to,
+			table.positionTypeId,
+			table.asset
+		],
+		foreignColumns: [
+			positions.chainId,
+			positions.contract,
+			positions.user,
+			positions.positionTypeId,
+			positions.asset
+		],
+		name: "transfers_positions_to_fk"
+	}).onDelete("cascade"),
+	index("transfers_chain_contract_user_idx").on(table.chainId, table.contract, table.from, table.to, table.blockNumber),
+	index("transfers_chain_type_block_idx").on(table.chainId, table.positionTypeId, table.blockNumber)
+]);
+const StatusCode = s.enum("status_code", Object.values(Status));
+const status = s.table("status", {
+	id: serial("id").primaryKey(),
+	code: StatusCode("code").unique()
+});
+const validations = s.table("validations", {
+	offerHash: varchar("offer_hash", { length: 66 }).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({
+	columns: [table.offerHash, table.obligationId],
+	name: "validations_pk"
+}), foreignKey({
+	columns: [table.offerHash, table.obligationId],
+	foreignColumns: [offers.hash, offers.obligationId],
+	name: "validations_offer_fk"
+}).onDelete("cascade")]);
+const collectors = s.table(EnumTableName.COLLECTORS, {
+	chainId: bigint("chain_id", { mode: "number" }).$type().notNull().references(() => chains.chainId, { onDelete: "no action" }),
+	name: text("name").$type().notNull(),
+	blockNumber: bigint("block_number", { mode: "number" }).notNull(),
+	epoch: numeric("epoch", {
+		precision: 78,
+		scale: 0
+	}).default("0").notNull(),
+	updatedAt: timestamp("updated_at").defaultNow().notNull()
+}, (table) => [uniqueIndex("collectors_chain_name_idx").on(table.chainId, table.name)]);
+const chains = s.table(EnumTableName.CHAINS, {
+	chainId: bigint("chain_id", { mode: "number" }).$type().notNull(),
+	blockNumber: bigint("block_number", { mode: "number" }).notNull(),
+	epoch: numeric("epoch", {
+		precision: 78,
+		scale: 0
+	}).default("0").notNull(),
+	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(),
+	createdAt: timestamp("created_at").defaultNow().notNull()
+});
+const merklePaths = s.table(EnumTableName.MERKLE_PATHS, {
+	offerHash: varchar("offer_hash", { length: 66 }).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()
+}, (table) => [
+	primaryKey({
+		columns: [table.offerHash, table.obligationId],
+		name: "merkle_paths_pk"
+	}),
+	foreignKey({
+		columns: [table.offerHash, table.obligationId],
+		foreignColumns: [offers.hash, offers.obligationId],
+		name: "merkle_paths_offer_fk"
+	}).onDelete("cascade"),
+	index("merkle_paths_tree_root_idx").on(table.treeRoot)
+]);
+
+//#endregion
+//#region src/database/domains/Groups.ts
+/** Build composite key for a group. */
+function compositeKey(g) {
+	return `${g.chainId}-${g.maker.toLowerCase()}-${g.group.toLowerCase()}`;
+}
+
 //#endregion
 //#region src/gatekeeper/Rules.ts
 var Rules_exports = /* @__PURE__ */ __exportAll({
-	amountMutualExclusivity: () => amountMutualExclusivity,
+	amountNonZero: () => amountNonZero,
 	callback: () => callback,
 	collateralToken: () => collateralToken,
+	groupConsistency: () => groupConsistency,
+	groupImmutability: () => groupImmutability,
 	loanToken: () => loanToken,
 	maturity: () => maturity,
+	maxCollaterals: () => maxCollaterals,
+	minDuration: () => minDuration,
 	oracle: () => oracle,
 	sameMaker: () => sameMaker
 });
@@ -5243,29 +6146,116 @@ 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.
+*/
+const minDuration = ({ minSeconds }) => single("min_duration", `Validates that offer duration (expiry - start) is at least ${minSeconds}s`, (offer) => {
+	const duration = offer.expiry - offer.start;
+	if (duration < minSeconds) return { message: `Duration ${duration}s is below minimum ${minSeconds}s` };
+});
+/**
+* A validation rule that checks if an offer exceeds the maximum number of collaterals.
+* The contract enforces this limit; this rule rejects early to avoid on-chain reverts.
+* @param max - Maximum allowed collaterals per offer.
+* @returns The issue that was found. If the offer is valid, this will be undefined.
+*/
+const maxCollaterals = ({ max }) => single("max_collaterals", `Validates that an offer has at most ${max} collaterals`, (offer) => {
+	if (offer.collaterals.length > max) return { message: `Offer has ${offer.collaterals.length} collaterals, exceeding the maximum of ${max}` };
+});
+/**
+* A validation rule that checks if the offer's obligationUnits 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" };
+});
+/**
+* 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,
+* 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) => {
+	const issues = /* @__PURE__ */ new Map();
+	if (offers.length === 0) return issues;
+	const groupMap = /* @__PURE__ */ new Map();
+	for (let i = 0; i < offers.length; i++) {
+		const key = offers[i].group.toLowerCase();
+		const indices = groupMap.get(key);
+		if (indices) indices.push(i);
+		else groupMap.set(key, [i]);
+	}
+	for (const indices of groupMap.values()) {
+		if (indices.length <= 1) continue;
+		const reference = offers[indices[0]];
+		const refLoanToken = reference.loanToken.toLowerCase();
+		const refUnits = reference.obligationUnits;
+		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.buy !== refBuy) issues.set(idx, { message: `All offers in a group must be on the same side. Expected ${refBuy ? "buy" : "sell"}, got ${offer.buy ? "buy" : "sell"}` });
+		}
+	}
+	return issues;
+});
+/**
+* A batch validation rule that prevents adding offers to groups that already exist in the database.
+* Groups are immutable after creation — new offers cannot be added to an existing group.
 */
-const 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" };
+const groupImmutability = ({ db, chainId }) => batch("group_immutability", "Validates that offers do not target groups that already exist", async (offers) => {
+	const issues = /* @__PURE__ */ new Map();
+	if (offers.length === 0) return issues;
+	const uniqueGroups = /* @__PURE__ */ new Map();
+	for (const offer of offers) {
+		const key = compositeKey({
+			chainId,
+			maker: offer.maker,
+			group: offer.group
+		});
+		if (!uniqueGroups.has(key)) uniqueGroups.set(key, {
+			chainId,
+			maker: offer.maker,
+			group: offer.group
+		});
+	}
+	const existingKeys = await db.groups.exists(Array.from(uniqueGroups.values()));
+	if (existingKeys.length === 0) return issues;
+	const existingSet = new Set(existingKeys.map((k) => compositeKey(k)));
+	for (let i = 0; i < offers.length; i++) {
+		const offer = offers[i];
+		const key = compositeKey({
+			chainId,
+			maker: offer.maker,
+			group: offer.group
+		});
+		if (existingSet.has(key)) issues.set(i, { message: `Cannot add offers to existing group ${offer.group}` });
+	}
+	return issues;
 });
 
 //#endregion
 //#region src/gatekeeper/morphoRules.ts
 const morphoRules = (parameters) => {
-	const { chains, chainId } = parameters;
+	const { chains, chainId, db } = parameters;
+	const requestChain = chains.find((c) => c.id === chainId);
+	const config = requestChain ? configs[requestChain.name] : void 0;
 	const assetsByChainId = {};
 	const collateralAssetsByChainId = {};
 	const oraclesByChainId = {};
 	for (const chain of chains) {
 		assetsByChainId[chain.id] = assets[chain.id.toString()] ?? [];
 		collateralAssetsByChainId[chain.id] = collateralAssets[chain.id.toString()] ?? [];
-		oraclesByChainId[chain.id] = oracles[chain.id.toString()] ?? [];
+		oraclesByChainId[chain.id] = oracles$1[chain.id.toString()] ?? [];
 	}
-	return [
+	const rules = [
 		sameMaker(),
-		amountMutualExclusivity(),
+		amountNonZero(),
+		groupConsistency(),
+		...config?.minDuration != null ? [minDuration({ minSeconds: config.minDuration })] : [],
 		maturity({ maturities: [MaturityType.EndOfWeek, MaturityType.EndOfNextWeek] }),
 		callback({
 			callbacks: [Type$1.BuyWithEmptyCallback, Type$1.SellWithEmptyCallback],
@@ -5275,6 +6265,7 @@ const morphoRules = (parameters) => {
 			assetsByChainId,
 			chainId
 		}),
+		maxCollaterals({ max: 128 }),
 		collateralToken({
 			collateralAssetsByChainId,
 			chainId
@@ -5284,6 +6275,11 @@ const morphoRules = (parameters) => {
 			chainId
 		})
 	];
+	if (db) rules.push(groupImmutability({
+		db,
+		chainId
+	}));
+	return rules;
 };
 
 //#endregion
@@ -5409,16 +6405,13 @@ async function* streamOffers(config, parameters) {
 	};
 }
 var WalletAccountNotSetError = class extends BaseError {
+	name = "Mempool.WalletAccountNotSetError";
 	constructor() {
 		super("Wallet account is not set.");
-		_defineProperty(this, "name", "Mempool.WalletAccountNotSetError");
 	}
 };
 var ViemClientError = class extends BaseError {
-	constructor(..._args) {
-		super(..._args);
-		_defineProperty(this, "name", "Mempool.ViemClientError");
-	}
+	name = "Mempool.ViemClientError";
 };
 const resolveSignatureDomain = (config, chainId) => {
 	const chain = config.client.chain;
@@ -5430,9 +6423,9 @@ const resolveSignatureDomain = (config, chainId) => {
 	};
 };
 var MissingMorphoAddressError = class extends BaseError {
+	name = "Mempool.MissingMorphoAddressError";
 	constructor() {
 		super("Morpho address is required to verify root signatures (zero address is invalid).");
-		_defineProperty(this, "name", "Mempool.MissingMorphoAddressError");
 	}
 };
 
@@ -5446,158 +6439,6 @@ function connect(parameters) {
 	return from(parameters);
 }
 
-//#endregion
-//#region src/utils/retry.ts
-const retry = async (fn, attempts = 3, delayMs = 50) => {
-	let lastErr;
-	for (let i = 0; i < attempts; i++) try {
-		return await fn();
-	} catch (err) {
-		lastErr = err;
-		if (i < attempts - 1) await new Promise((r) => setTimeout(r, delayMs));
-	}
-	throw lastErr;
-};
-
-//#endregion
-//#region src/utils/batchMulticall.ts
-/**
-* Helper function to execute multicall in batches with retry logic.
-* Abstracts the common pattern of batching calls, retrying, and collecting results.
-*
-* @param parameters - Configuration for batched multicall
-* @returns Promise resolving to flattened array of results
-*/
-async function batchMulticall(parameters) {
-	const { client, calls, batchSize, retryAttempts, retryDelayMs, blockNumber } = parameters;
-	const results = [];
-	for (const callsBatch of batch$1(calls, batchSize)) {
-		const batchResults = await retry(() => multicall(client, {
-			allowFailure: false,
-			contracts: callsBatch,
-			...blockNumber ? { blockNumber } : {}
-		}), retryAttempts, retryDelayMs);
-		results.push(...batchResults);
-	}
-	return results;
-}
-
-//#endregion
-//#region src/utils/Group.ts
-var Group_exports = /* @__PURE__ */ __exportAll({ fromNumber: () => fromNumber });
-/**
-* Creates a bytes32 group identifier from a number.
-* @param n - A non-negative integer.
-* @throws {Error} If n is negative or not an integer.
-*/
-const fromNumber = (n) => {
-	if (!Number.isInteger(n)) throw new Error(`Group.fromNumber: expected integer, got ${n}`);
-	if (n < 0) throw new Error(`Group.fromNumber: expected non-negative, got ${n}`);
-	return pad(`0x${n.toString(16)}`, { size: 32 });
-};
-
-//#endregion
-//#region src/utils/lazy.ts
-/**
-* Transform a polling function into an async generator.
-* @param fn - The polling function to transform.
-* @returns An async generator.
-*/
-function lazy(pollFn) {
-	return () => (async function* () {
-		let active = true;
-		let resolveNext = null;
-		const queue = [];
-		const wait = () => new Promise((resolve) => {
-			resolveNext = resolve;
-		});
-		const emit = (item) => {
-			queue.push(item);
-			resolveNext?.();
-			resolveNext = null;
-		};
-		let unpoll = null;
-		const stop = () => {
-			active = false;
-			unpoll?.();
-			resolveNext?.();
-			resolveNext = null;
-		};
-		unpoll = pollFn(emit, { stop });
-		try {
-			while (active) {
-				if (queue.length === 0) await wait();
-				while (queue.length > 0 && active) yield queue.shift();
-			}
-		} finally {
-			stop();
-		}
-	})();
-}
-
-//#endregion
-//#region src/utils/wait.ts
-async function wait(time) {
-	return new Promise((res) => setTimeout(res, time));
-}
-
-//#endregion
-//#region src/utils/poll.ts
-/**
-* Polls a function at a specified interval.
-* Inspired by https://github.com/wevm/viem/blob/845994d20275d08ff892018e237a4b599eeefb6a/src/utils/poll.ts
-*/
-function poll(fn, { interval }) {
-	let active = true;
-	const unwatch = () => active = false;
-	const watch = async () => {
-		while (active) {
-			const delay = await interval();
-			if (!active) break;
-			await wait(delay);
-			if (!active) break;
-			await fn({ unpoll: unwatch });
-		}
-	};
-	watch();
-	return unwatch;
-}
-
-//#endregion
-//#region src/utils/time.ts
-var time_exports = /* @__PURE__ */ __exportAll({
-	max: () => max,
-	now: () => now
-});
-function now() {
-	return Math.floor(Date.now() / 1e3);
-}
-function max() {
-	return 0x77e772392b600000;
-}
-
-//#endregion
-//#region src/utils/index.ts
-var utils_exports = /* @__PURE__ */ __exportAll({
-	BaseError: () => BaseError,
-	Group: () => Group_exports,
-	Random: () => Random_exports,
-	ReorgError: () => ReorgError,
-	Time: () => time_exports,
-	atMostOneNonZero: () => atMostOneNonZero,
-	batch: () => batch$1,
-	batchMulticall: () => batchMulticall,
-	fromSnakeCase: () => fromSnakeCase$3,
-	lazy: () => lazy,
-	max: () => max$1,
-	min: () => min,
-	poll: () => poll,
-	retry: () => retry,
-	stringifyBigint: () => stringifyBigint,
-	toSnakeCase: () => toSnakeCase$1,
-	wait: () => wait
-});
-
 //#endregion
 export { Abi_exports as Abi, BrandTypeId, Callback_exports as Callback, Chain_exports as Chain, ChainRegistry_exports as ChainRegistry, Collateral_exports as Collateral, ERC4626_exports as ERC4626, Errors_exports as Errors, Format_exports as Format, Gatekeeper_exports as Gatekeeper, Client_exports as GatekeeperClient, Id_exports as Id, LLTV_exports as LLTV, Liquidity_exports as Liquidity, Maturity_exports as Maturity, MempoolClient_exports as Mempool, Obligation_exports as Obligation, Offer_exports as Offer, Oracle_exports as Oracle, Position_exports as Position, Quote_exports as Quote, Schema_exports as RouterApi, Client_exports$1 as RouterClient, Rules_exports as Rules, Tick_exports as Tick, time_exports as Time, TradingFee_exports as TradingFee, Transfer_exports as Transfer, Tree_exports as Tree, utils_exports as Utils, Gate_exports as Validation, morphoRules };
 //# sourceMappingURL=index.browser.mjs.map