@morpho-dev/router 0.7.1 → 0.8.0

package/dist/cli.js

@@ -152,7 +152,7 @@ function startActiveSpan(tracer, name, fn) {
 //#endregion
 //#region package.json
 var name = "@morpho-dev/router";
-var version = "0.7.1";
+var version = "0.8.0";
 var description = "Router package for Morpho protocol";
 
 //#endregion
@@ -331,8 +331,8 @@ const chains$2 = {
 		name: "ethereum-virtual-testnet",
 		custom: {
 			morpho: {
-				address: "0x11a002d45db720ed47a80d2f3489cba5b833eaf5",
-				blockCreated: 0
+				address: "0x634b095371e4e45feed94c1a45c37798e173ea50",
+				blockCreated: 23226700
 			},
 			morphoBlue: {
 				address: "0xBBBBBbbBBb9cC5e90e3b3Af64bdAF62C37EEFFCb",
@@ -561,7 +561,7 @@ async function deployContract(client, account, bytecode, name) {
 */
 async function startAnvil(parameters) {
 	const args = buildAnvilArgs(parameters);
-	const logFd = fs.openSync(parameters.logPath, "a");
+	const logFd = fs.openSync(parameters.logPath, "w");
 	const subprocess = spawn("anvil", args, {
 		detached: true,
 		stdio: [
@@ -1640,6 +1640,33 @@ const assets = {
 		"0x2260FAC5E5542a773Aa44fBCfeDf7C193bc2C599"
 	]
 };
+const collateralAssets = {
+	[ChainId.ETHEREUM.toString()]: [
+		"0xA0b86991c6218b36c1d19D4a2e9Eb0cE3606eB48",
+		"0x1aBaEA1f7C830bD89Acc67eC4af516284b1bC33c",
+		"0x2260FAC5E5542a773Aa44fBCfeDf7C193bc2C599",
+		"0x7f39C581F595B53c5cb19bD0b3f8dA6c935E2Ca0"
+	],
+	[ChainId.BASE.toString()]: [
+		"0x833589fCD6eDb6E08f4c7C32D4f71b54bdA02913",
+		"0x4200000000000000000000000000000000000006",
+		"0xcbB7C0000aB88B473b1f5aFd9ef808440eed33Bf",
+		"0xc1CBa3fCea344f92D9239c08C0568f6F2F0ee452",
+		"0x60a3E35Cc302bFA44Cb288Bc5a4F316Fdb1adb42"
+	],
+	[ChainId["ETHEREUM-VIRTUAL-TESTNET"].toString()]: [
+		"0xA0b86991c6218b36c1d19D4a2e9Eb0cE3606eB48",
+		"0x1aBaEA1f7C830bD89Acc67eC4af516284b1bC33c",
+		"0x2260FAC5E5542a773Aa44fBCfeDf7C193bc2C599",
+		"0x7f39C581F595B53c5cb19bD0b3f8dA6c935E2Ca0"
+	],
+	[ChainId.ANVIL.toString()]: [
+		"0xA0b86991c6218b36c1d19D4a2e9Eb0cE3606eB48",
+		"0x1aBaEA1f7C830bD89Acc67eC4af516284b1bC33c",
+		"0x2260FAC5E5542a773Aa44fBCfeDf7C193bc2C599",
+		"0x7f39C581F595B53c5cb19bD0b3f8dA6c935E2Ca0"
+	]
+};
 const oracles$1 = {
 	[ChainId.ETHEREUM.toString()]: [
 		"0xDddd770BADd886dF3864029e4B377B5F6a2B6b83",
@@ -1714,6 +1741,61 @@ const MetaMorpho = parseAbi([
 //#region src/core/Abi/MetaMorphoFactory.ts
 const MetaMorphoFactory = parseAbi(["event CreateMetaMorpho(address indexed metaMorpho,address indexed caller,address initialOwner,uint256 initialTimelock,address indexed asset,string name,string symbol,bytes32 salt)", "function isMetaMorpho(address) view returns (bool)"]);
 
+//#endregion
+//#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 consumed(address user, bytes32 group) view returns (uint256)",
+	"function debtOf(bytes32 id, address user) view returns (uint256)",
+	"function defaultFees(address loanToken, uint256 index) view returns (uint16)",
+	"function feeSetter() view returns (address)",
+	"function fees(bytes32 id) view returns (uint16[6])",
+	"function 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 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 owner() view returns (address)",
+	"function repay((address loanToken, (address token, uint256 lltv, address oracle)[] collaterals, uint256 maturity) obligation, uint256 obligationUnits, address onBehalf)",
+	"function session(address user) view returns (bytes32)",
+	"function setDefaultTradingFee(address loanToken, uint256 index, uint256 newTradingFee)",
+	"function setFeeSetter(address newFeeSetter)",
+	"function setObligationTradingFee(bytes32 id, uint256 index, uint256 newTradingFee)",
+	"function setOwner(address newOwner)",
+	"function setTradingFeeRecipient(address recipient)",
+	"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 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) offer, (uint8 v, bytes32 r, bytes32 s) sig, bytes32 root, bytes32[] proof, address takerCallback, bytes takerCallbackData) returns (uint256, uint256, uint256, uint256)",
+	"function totalShares(bytes32 id) view returns (uint256)",
+	"function totalUnits(bytes32 id) view returns (uint256)",
+	"function touchObligation((address loanToken, (address token, uint256 lltv, address oracle)[] collaterals, uint256 maturity) obligation) returns (bytes32)",
+	"function tradingFee(bytes32 id, uint256 timeToMaturity) view returns (uint256)",
+	"function tradingFeeRecipient() view returns (address)",
+	"function withdraw((address loanToken, (address token, uint256 lltv, address oracle)[] collaterals, uint256 maturity) obligation, uint256 obligationUnits, uint256 shares, address onBehalf) returns (uint256, uint256)",
+	"function withdrawCollateral((address loanToken, (address token, uint256 lltv, address oracle)[] collaterals, uint256 maturity) obligation, address collateral, uint256 assets, address onBehalf)",
+	"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 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 SetOwner(address indexed owner)",
+	"event SetTradingFeeRecipient(address indexed recipient)",
+	"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, bytes32 group, uint256 consumed)",
+	"event Withdraw(address indexed caller, bytes32 indexed id, uint256 obligationUnits, uint256 shares, address indexed onBehalf)",
+	"event WithdrawCollateral(address caller, bytes32 indexed id, address indexed collateral, uint256 assets, address indexed onBehalf)"
+]);
+
 //#endregion
 //#region src/core/Abi/index.ts
 const Oracle = [{
@@ -2071,7 +2153,7 @@ const OfferSchema = () => {
 		assets: z$2.bigint({ coerce: true }).min(0n).max(maxUint256),
 		obligationUnits: z$2.bigint({ coerce: true }).min(0n).max(maxUint256).optional().default(0n),
 		obligationShares: z$2.bigint({ coerce: true }).min(0n).max(maxUint256).optional().default(0n),
-		price: z$2.bigint({ coerce: true }).min(0n).max(maxUint256),
+		tick: z$2.coerce.number().int().min(0).max(990),
 		maturity: MaturitySchema,
 		expiry: z$2.number().int().max(Number.MAX_SAFE_INTEGER),
 		start: z$2.number().int().max(Number.MAX_SAFE_INTEGER),
@@ -2143,7 +2225,7 @@ const serialize = (offer) => ({
 	assets: offer.assets.toString(),
 	obligationUnits: offer.obligationUnits.toString(),
 	obligationShares: offer.obligationShares.toString(),
-	price: offer.price.toString(),
+	tick: offer.tick,
 	maturity: Number(offer.maturity),
 	expiry: Number(offer.expiry),
 	start: Number(offer.start),
@@ -2188,14 +2270,13 @@ function random(config) {
 		[.98, 2]
 	]));
 	const buy = config?.buy !== void 0 ? config.buy : bool();
-	const ONE = 1000000000000000000n;
-	const qMin = buy ? 16 : 4;
-	const len = (buy ? 32 : 16) - qMin + 1;
-	const pricePairs = Array.from({ length: len }, (_, idx) => {
-		const q = qMin + idx;
-		return [BigInt(q) * (ONE / 4n), buy ? 1 + idx : 1 + (len - 1 - idx)];
+	const tickMin = buy ? 0 : 495;
+	const len = (buy ? 495 : 990) - tickMin + 1;
+	const tickPairs = Array.from({ length: len }, (_, idx) => {
+		const weight = buy ? 1 + idx : 1 + (len - 1 - idx);
+		return [tickMin + idx, weight];
 	});
-	const price = config?.price ?? weightedChoice(pricePairs);
+	const tick = config?.tick ?? weightedChoice(tickPairs);
 	const loanTokenDecimals = config?.assetsDecimals?.[loanToken] ?? 18;
 	const unit = BigInt(10) ** BigInt(loanTokenDecimals);
 	const amountBase = BigInt(100 + int(999901));
@@ -2209,7 +2290,7 @@ function random(config) {
 		assets: assetsScaled,
 		obligationUnits: config?.obligationUnits ?? 0n,
 		obligationShares: config?.obligationShares ?? 0n,
-		price,
+		tick,
 		maturity,
 		expiry: config?.expiry ?? maturity - 1,
 		start: config?.start ?? maturity - 10,
@@ -2274,7 +2355,7 @@ const types = {
 			type: "uint256"
 		},
 		{
-			name: "price",
+			name: "tick",
 			type: "uint256"
 		},
 		{
@@ -2342,7 +2423,7 @@ function hash(offer) {
 			assets: offer.assets,
 			obligationUnits: offer.obligationUnits,
 			obligationShares: offer.obligationShares,
-			price: offer.price,
+			tick: BigInt(offer.tick),
 			maturity: BigInt(offer.maturity),
 			expiry: BigInt(offer.expiry),
 			group: offer.group,
@@ -2607,6 +2688,49 @@ var InvalidQuoteError = class extends BaseError {
 	}
 };
 
+//#endregion
+//#region src/core/Tick.ts
+/** ln(1 + 0.025), scaled by 1e18. Matches TickLib onchain constant. */
+const LN_ONE_PLUS_DELTA = 24692612590371501n;
+/** ln(2), scaled by 1e18. Matches TickLib onchain constant. */
+const LN2 = 693147180559945309n;
+const WAD$1 = 10n ** 18n;
+const WAD_SQUARED = 10n ** 36n;
+const PRICE_STEP = 10n ** 13n;
+const HALF_TICK_RANGE = 495n;
+/** Tick domain supported by Morpho V2. */
+const TICK_RANGE = 990;
+/**
+* Converts a tick to a wad price using the same approximation and rounding as TickLib.
+* @param tick - Tick value in the inclusive range [0, 990].
+* @returns The price in wad units.
+* @throws {@link InvalidTickError} If tick is not an integer in range [0, 990].
+*/
+function tickToPrice(tick) {
+	assertTick(tick);
+	return divHalfDownUnchecked(divHalfDownUnchecked(WAD_SQUARED, WAD$1 + wExp(LN_ONE_PLUS_DELTA * (HALF_TICK_RANGE - BigInt(tick)))), PRICE_STEP) * PRICE_STEP;
+}
+function divHalfDownUnchecked(x, d) {
+	return (x + (d - 1n) / 2n) / d;
+}
+function wExp(x) {
+	if (x < 0n) return WAD_SQUARED / wExp(-x);
+	const q = (x + LN2 / 2n) / LN2;
+	const r = x - q * LN2;
+	const secondTerm = r * r / (2n * WAD$1);
+	const thirdTerm = secondTerm * r / (3n * WAD$1);
+	return WAD$1 + r + secondTerm + thirdTerm << q;
+}
+function assertTick(tick) {
+	if (!Number.isInteger(tick) || tick < 0 || tick > TICK_RANGE) throw new InvalidTickError(tick);
+}
+var InvalidTickError = class extends BaseError {
+	name = "Tick.InvalidTickError";
+	constructor(tick) {
+		super(`Invalid tick: ${tick}. Tick must be an integer between 0 and ${TICK_RANGE}.`);
+	}
+};
+
 //#endregion
 //#region src/core/TradingFee.ts
 /** WAD constant (1e18) for fee scaling. */
@@ -2895,15 +3019,25 @@ const callback = ({ callbacks }) => single("callback", `Validates callbacks: buy
 	if (isEmptyCallback(offer) && !offer.buy && !callbacks.includes(Type$1.SellWithEmptyCallback)) return { message: "Sell offers with empty callback not allowed." };
 });
 /**
-* A validation rule that checks if the offer's tokens are allowed for its chain.
-* @param assetsByChainId - Allowed assets indexed by chain id.
+* A validation rule that checks if the offer's loan token is allowed for its chain.
+* @param assetsByChainId - Allowed loan tokens indexed by chain id.
 * @returns The issue that was found. If the offer is valid, this will be undefined.
 */
-const token = ({ assetsByChainId }) => single("token", "Validates that offer loan token and collateral tokens are in the allowed assets list for the offer chain", (offer) => {
-	const allowedAssets = assetsByChainId[offer.chainId]?.map((asset) => asset.toLowerCase());
-	if (!allowedAssets || allowedAssets.length === 0) return { message: `No allowed assets for chain ${offer.chainId}` };
-	if (!allowedAssets.includes(offer.loanToken.toLowerCase())) return { message: "Loan token is not allowed" };
-	if (offer.collaterals.some((collateral) => !allowedAssets.includes(collateral.asset.toLowerCase()))) return { message: "Collateral is not allowed" };
+const loanToken = ({ assetsByChainId }) => single("loan_token", "Validates that offer loan token is in the allowed token list for the offer chain", (offer) => {
+	const allowedLoanTokens = assetsByChainId[offer.chainId]?.map((asset) => asset.toLowerCase());
+	if (!allowedLoanTokens || allowedLoanTokens.length === 0) return { message: `No allowed loan tokens for chain ${offer.chainId}` };
+	if (!allowedLoanTokens.includes(offer.loanToken.toLowerCase())) return { message: "Loan token is not allowed" };
+});
+/**
+* A validation rule that checks if the offer's collateral tokens are allowed for its chain.
+* @param collateralAssetsByChainId - Allowed collateral tokens indexed by chain id.
+* @returns The issue that was found. If the offer is valid, this will be undefined.
+*/
+const collateralToken = ({ collateralAssetsByChainId }) => single("collateral_token", "Validates that offer collateral tokens are in the allowed token list for the offer chain", (offer) => {
+	const allowedCollateralTokens = collateralAssetsByChainId[offer.chainId]?.map((asset) => asset.toLowerCase()) ?? [];
+	if (allowedCollateralTokens.length === 0) return { message: `No allowed collateral tokens for chain ${offer.chainId}` };
+	if (offer.collaterals.length === 0) return { message: "At least one collateral token is required" };
+	if (offer.collaterals.some((collateral) => !allowedCollateralTokens.includes(collateral.asset.toLowerCase()))) return { message: "Collateral token is not allowed" };
 });
 /**
 * A validation rule that checks if the offer's oracle addresses are allowed for its chain.
@@ -2946,9 +3080,11 @@ const amountMutualExclusivity = () => single("amount_mutual_exclusivity", "Valid
 //#region src/gatekeeper/morphoRules.ts
 const morphoRules = (chains) => {
 	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$1[chain.id.toString()] ?? [];
 	}
 	return [
@@ -2960,7 +3096,8 @@ const morphoRules = (chains) => {
 			callbacks: [Type$1.BuyWithEmptyCallback, Type$1.SellWithEmptyCallback],
 			allowedAddresses: []
 		}),
-		token({ assetsByChainId }),
+		loanToken({ assetsByChainId }),
+		collateralToken({ collateralAssetsByChainId }),
 		oracle({ oraclesByChainId })
 	];
 };
@@ -2968,7 +3105,7 @@ const morphoRules = (chains) => {
 //#endregion
 //#region src/gatekeeper/ConfigRules.ts
 /**
-* Build the configured rules (maturities + callback addresses + loan tokens + oracles) for the provided chains.
+* Build the configured rules (maturities + callback addresses + loan tokens + collateral tokens + oracles) for the provided chains.
 * @param chains - Chains to include in the configured rules.
 * @returns Sorted list of config rules.
 */
@@ -2988,6 +3125,12 @@ function buildConfigRules(chains) {
 			chain_id: chain.id,
 			address: normalizeAddress(address)
 		});
+		const collateralTokens = collateralAssets[chain.id.toString()] ?? [];
+		for (const address of collateralTokens) rules.push({
+			type: "collateral_token",
+			chain_id: chain.id,
+			address: normalizeAddress(address)
+		});
 		const oracles = oracles$1[chain.id.toString()] ?? [];
 		for (const address of oracles) rules.push({
 			type: "oracle",
@@ -3015,6 +3158,10 @@ function buildConfigRulesChecksum(rules) {
 			hash.update(`callback:${rule.chain_id}:${rule.callback_type}:${rule.address}\n`);
 			continue;
 		}
+		if (rule.type === "collateral_token") {
+			hash.update(`collateral_token:${rule.chain_id}:${rule.address}\n`);
+			continue;
+		}
 		if (rule.type === "oracle") {
 			hash.update(`oracle:${rule.chain_id}:${rule.address}\n`);
 			continue;
@@ -3035,6 +3182,7 @@ function compareConfigRules(left, right) {
 		return left.address.localeCompare(right.address);
 	}
 	if (left.type === "loan_token" && right.type === "loan_token") return left.address.localeCompare(right.address);
+	if (left.type === "collateral_token" && right.type === "collateral_token") return left.address.localeCompare(right.address);
 	if (left.type === "oracle" && right.type === "oracle") return left.address.localeCompare(right.address);
 	return 0;
 }
@@ -3042,8 +3190,10 @@ function compareConfigRules(left, right) {
 //#endregion
 //#region src/api/Schema/BookResponse.ts
 function from$6(level) {
+	const price = tickToPrice(level.tick);
 	return {
-		price: level.price.toString(),
+		tick: level.tick,
+		price: price.toString(),
 		assets: level.assets.toString(),
 		count: level.count
 	};
@@ -3109,6 +3259,16 @@ function from$5(obligation, quote) {
 
 //#endregion
 //#region src/api/Schema/OfferResponse.ts
+function normalizeChainId(chainId) {
+	const parsedChainId = Number(chainId);
+	if (!Number.isInteger(parsedChainId) || parsedChainId <= 0) throw new Error(`Invalid chain id: ${String(chainId)}`);
+	return parsedChainId;
+}
+function normalizeBlockNumber(blockNumber) {
+	const parsedBlockNumber = Number(blockNumber);
+	if (!Number.isInteger(parsedBlockNumber) || parsedBlockNumber < 0) throw new Error(`Invalid block number: ${String(blockNumber)}`);
+	return parsedBlockNumber;
+}
 /**
 * Creates an `OfferResponse` matching the Solidity Offer struct layout.
 * @constructor
@@ -3116,6 +3276,8 @@ function from$5(obligation, quote) {
 * @returns The created `OfferResponse`. {@link OfferResponse}
 */
 function from$4(input) {
+	const chainId = normalizeChainId(input.chainId);
+	const blockNumber = normalizeBlockNumber(input.blockNumber);
 	const base = {
 		offer: {
 			obligation: {
@@ -3134,7 +3296,7 @@ function from$4(input) {
 			obligation_shares: input.obligationShares.toString(),
 			start: input.start,
 			expiry: input.expiry,
-			price: input.price.toString(),
+			tick: input.tick,
 			group: input.group,
 			session: input.session,
 			callback: input.callback.address,
@@ -3142,15 +3304,15 @@ function from$4(input) {
 		},
 		offer_hash: input.hash,
 		obligation_id: id({
-			chainId: input.chainId,
+			chainId,
 			loanToken: input.loanToken,
 			collaterals: [...input.collaterals],
 			maturity: input.maturity
 		}),
-		chain_id: input.chainId,
+		chain_id: chainId,
 		consumed: input.consumed.toString(),
 		takeable: input.takeable.toString(),
-		block_number: input.blockNumber
+		block_number: blockNumber
 	};
 	if (!input.proof || !input.root || !input.signature) return {
 		...base,
@@ -3296,7 +3458,7 @@ const offerExample = {
 		obligation_shares: "0",
 		start: 1761922790,
 		expiry: 1761922799,
-		price: "2750000000000000000",
+		tick: 495,
 		group: "0x000000000000000000000000000000000000000000000000000000000008b8f4",
 		session: "0x0000000000000000000000000000000000000000000000000000000000000000",
 		callback: "0x0000000000000000000000000000000000000000",
@@ -3337,7 +3499,7 @@ const validateOfferExample = {
 	assets: "369216000000000000000000",
 	obligation_units: "0",
 	obligation_shares: "0",
-	price: "2750000000000000000",
+	tick: 495,
 	maturity: 1761922799,
 	expiry: 1761922799,
 	start: 1761922790,
@@ -3481,9 +3643,11 @@ __decorate([ApiProperty({
 	example: offerExample.offer.expiry
 })], OfferDataResponse.prototype, "expiry", void 0);
 __decorate([ApiProperty({
-	type: "string",
-	example: offerExample.offer.price
-})], OfferDataResponse.prototype, "price", void 0);
+	type: "number",
+	example: offerExample.offer.tick,
+	minimum: 0,
+	maximum: 990
+})], OfferDataResponse.prototype, "tick", void 0);
 __decorate([ApiProperty({
 	type: "string",
 	example: offerExample.offer.group
@@ -3724,9 +3888,11 @@ __decorate([ApiProperty({
 	required: false
 })], ValidateOfferRequest.prototype, "obligation_shares", void 0);
 __decorate([ApiProperty({
-	type: "string",
-	example: validateOfferExample.price
-})], ValidateOfferRequest.prototype, "price", void 0);
+	type: "number",
+	example: validateOfferExample.tick,
+	minimum: 0,
+	maximum: 990
+})], ValidateOfferRequest.prototype, "tick", void 0);
 __decorate([ApiProperty({
 	type: "number",
 	example: validateOfferExample.maturity
@@ -3826,9 +3992,16 @@ __decorate([ApiProperty({
 	description: "List of validation issues. Returned when any offer fails validation."
 })], ValidationFailureResponse.prototype, "data", void 0);
 var BookLevelResponse = class {};
+__decorate([ApiProperty({
+	type: "number",
+	example: 495,
+	minimum: 0,
+	maximum: 990
+})], BookLevelResponse.prototype, "tick", void 0);
 __decorate([ApiProperty({
 	type: "string",
-	example: "2750000000000000000"
+	example: "500000000000000000",
+	description: "Price derived from tick, scaled by 1e18."
 })], BookLevelResponse.prototype, "price", void 0);
 __decorate([ApiProperty({
 	type: "string",
@@ -3842,6 +4015,7 @@ const positionExample = {
 	chain_id: 1,
 	contract: "0xC9A9C45C0eB717f8b5F193Af6bAa05A1c0Ac5078",
 	user: "0x7b093658BE7f90B63D7c359e8f408e503c2D9401",
+	obligation_id: "0x12590ae1aee324a005be565f3bcdd16dbf8daf7969b26c181c8b8f467dad9f67",
 	reserved: "200000000000000000000",
 	block_number: 21345678
 };
@@ -3858,6 +4032,12 @@ __decorate([ApiProperty({
 	type: "string",
 	example: positionExample.user
 })], PositionListItemResponse.prototype, "user", void 0);
+__decorate([ApiProperty({
+	type: "string",
+	nullable: true,
+	example: positionExample.obligation_id,
+	description: "Obligation id this reserved amount belongs to, or null if no lots exist."
+})], PositionListItemResponse.prototype, "obligation_id", void 0);
 __decorate([ApiProperty({
 	type: "string",
 	example: positionExample.reserved
@@ -3885,7 +4065,7 @@ __decorate([ApiProperty({
 })], BookListResponse.prototype, "cursor", void 0);
 __decorate([ApiProperty({
 	type: () => [BookLevelResponse],
-	description: "Aggregated book levels grouped by computed price."
+	description: "Aggregated book levels grouped by offer tick."
 })], BookListResponse.prototype, "data", void 0);
 let BooksController = class BooksController {
 	async getBook() {}
@@ -3895,7 +4075,7 @@ __decorate([
 		methods: ["get"],
 		path: "/v1/books/{obligationId}/{side}",
 		summary: "Get aggregated book",
-		description: "Returns aggregated book data for a given obligation and side. Offers are grouped by computed price with summed takeable amounts. Book levels are sorted by price (ascending for buy side, descending for sell side)."
+		description: "Returns aggregated book data for a given obligation and side. Offers are grouped by tick with summed takeable amounts, and each level includes the corresponding wad-scaled price. Book levels are sorted by tick (ascending for sell side, descending for buy side)."
 	}),
 	ApiParam({
 		name: "obligationId",
@@ -3920,7 +4100,7 @@ __decorate([
 		name: "limit",
 		type: "number",
 		example: 10,
-		description: "Maximum number of price levels to return."
+		description: "Maximum number of tick levels to return."
 	}),
 	ApiResponse({
 		status: 200,
@@ -4114,6 +4294,11 @@ const configRulesLoanTokenExample = {
 	chain_id: 1,
 	address: "0xA0b86991c6218b36c1d19D4a2e9Eb0cE3606eB48"
 };
+const configRulesCollateralTokenExample = {
+	type: "collateral_token",
+	chain_id: 1,
+	address: "0x7f39C581F595B53c5cb19bD0b3f8dA6c935E2Ca0"
+};
 const configRulesOracleExample = {
 	type: "oracle",
 	chain_id: 1,
@@ -4123,6 +4308,7 @@ const configRulesChecksumExample = "f1d2d2f924e986ac86fdf7b36c94bcdf";
 const configRulesPayloadExample = [
 	configRulesMaturityExample,
 	configRulesLoanTokenExample,
+	configRulesCollateralTokenExample,
 	configRulesOracleExample
 ];
 const configContractNames = [
@@ -4249,7 +4435,7 @@ __decorate([
 		methods: ["get"],
 		path: "/v1/config/rules",
 		summary: "Get config rules",
-		description: "Returns configured rules (maturities, loan tokens, oracles) for supported chains."
+		description: "Returns configured rules (maturities, loan tokens, collateral tokens, oracles) for supported chains."
 	}),
 	ApiQuery({
 		name: "cursor",
@@ -4269,7 +4455,7 @@ __decorate([
 		name: "types",
 		type: ["string"],
 		required: false,
-		example: "maturity,loan_token,oracle",
+		example: "maturity,loan_token,collateral_token,oracle",
 		description: "Filter by rule types (comma-separated).",
 		style: "form",
 		explode: false
@@ -4387,7 +4573,7 @@ __decorate([
 		methods: ["get"],
 		path: "/v1/users/{userAddress}/positions",
 		summary: "Get user positions",
-		description: "Returns positions for a user with reserved balance. The reserved balance is the amount locked by active offers (max lot upper - offset - consumed)."
+		description: "Returns positions for a user with reserved balance per obligation. Each (position, obligation) pair is returned as a separate row. Positions with no lots return a single row with obligation_id = null and reserved = 0."
 	}),
 	ApiParam({
 		name: "userAddress",
@@ -4474,6 +4660,7 @@ function from$3(position) {
 		chain_id: position.chainId,
 		contract: position.contract,
 		user: position.user,
+		obligation_id: position.obligationId,
 		reserved: position.reserved.toString(),
 		block_number: position.blockNumber
 	};
@@ -4527,10 +4714,11 @@ const ConfigRuleTypes = z$2.enum([
 	"maturity",
 	"callback",
 	"loan_token",
+	"collateral_token",
 	"oracle"
 ]);
 const GetConfigRulesQueryParams = z$2.object({
-	cursor: z$2.string().regex(/^(maturity|callback|loan_token|oracle):[1-9]\d*:.+$/, { message: "Cursor must be in the format type:chain_id:<value>" }).optional().meta({
+	cursor: z$2.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({
 		description: "Pagination cursor in type:chain_id:<value> format",
 		example: "maturity:1:1730415600:end_of_next_month"
 	}),
@@ -4540,7 +4728,7 @@ const GetConfigRulesQueryParams = z$2.object({
 	}),
 	types: csvArray(ConfigRuleTypes).meta({
 		description: "Filter by rule types (comma-separated).",
-		example: "maturity,loan_token,oracle"
+		example: "maturity,loan_token,collateral_token,oracle"
 	}),
 	chains: csvArray(z$2.string().regex(/^[1-9]\d*$/, { message: "Chain must be a positive integer" }).transform((val) => Number.parseInt(val, 10))).meta({
 		description: "Filter by chain IDs (comma-separated).",
@@ -4640,12 +4828,11 @@ const GetObligationParams = z$2.object({ obligation_id: z$2.string({ error: "Obl
 	description: "Obligation id",
 	example: "0x1234567890123456789012345678901234567890123456789012345678901234"
 }) });
-/** Validate a book cursor format: {side, lastPrice, offersCursor} */
+/** Validate a book cursor format: {side, lastTick, offersCursor} */
 function isValidBookCursor(cursorString) {
-	const isNumericString = (value) => typeof value === "string" && /^-?\d+$/.test(value);
 	try {
 		const v = JSON.parse(Buffer.from(cursorString, "base64url").toString("utf8"));
-		return (v?.side === "buy" || v?.side === "sell") && isNumericString(v?.lastPrice) && (v?.offersCursor === null || typeof v?.offersCursor === "string");
+		return (v?.side === "buy" || v?.side === "sell") && typeof v?.lastTick === "number" && Number.isInteger(v.lastTick) && (v?.offersCursor === null || typeof v?.offersCursor === "string");
 	} catch {
 		return false;
 	}
@@ -4750,6 +4937,7 @@ function formatCursor$1(rule) {
 	if (rule.type === "maturity") return `maturity:${rule.chain_id}:${rule.timestamp}:${rule.name}`;
 	if (rule.type === "callback") return `callback:${rule.chain_id}:${rule.callback_type}:${rule.address.toLowerCase()}`;
 	if (rule.type === "oracle") return `oracle:${rule.chain_id}:${rule.address.toLowerCase()}`;
+	if (rule.type === "collateral_token") return `collateral_token:${rule.chain_id}:${rule.address.toLowerCase()}`;
 	return `loan_token:${rule.chain_id}:${rule.address.toLowerCase()}`;
 }
 function parseCursor$1(cursor) {
@@ -4782,7 +4970,7 @@ function parseCursor$1(cursor) {
 			address: parseAddress(addressValue, "Cursor address")
 		};
 	}
-	if (type === "loan_token" || type === "oracle") {
+	if (type === "loan_token" || type === "collateral_token" || type === "oracle") {
 		const addressValue = rest.join(":");
 		if (!addressValue) throw new BadRequestError(`Cursor must be in the format ${type}:chain_id:address`);
 		return {
@@ -4809,7 +4997,7 @@ function parseAddress(address, label) {
 	return address.toLowerCase();
 }
 function isConfigRuleType(value) {
-	return value === "maturity" || value === "callback" || value === "loan_token" || value === "oracle";
+	return value === "maturity" || value === "callback" || value === "loan_token" || value === "collateral_token" || value === "oracle";
 }
 function isMaturityType(value) {
 	return Object.values(MaturityType).includes(value);
@@ -5082,7 +5270,7 @@ function now() {
 
 //#endregion
 //#region src/database/drizzle/VERSION.ts
-const VERSION = "router_v1.6";
+const VERSION = "router_v1.8";
 
 //#endregion
 //#region src/database/drizzle/schema.ts
@@ -5234,10 +5422,7 @@ const offers = s.table(EnumTableName.OFFERS, {
 		precision: 78,
 		scale: 0
 	}).notNull().default("0"),
-	price: numeric("price", {
-		precision: 78,
-		scale: 0
-	}).notNull(),
+	tick: integer("tick").notNull(),
 	maturity: integer("maturity").notNull(),
 	expiry: integer("expiry").notNull(),
 	start: integer("start").notNull(),
@@ -5302,6 +5487,7 @@ const lots = s.table(EnumTableName.LOTS, {
 	user: varchar("user", { length: 42 }).notNull(),
 	contract: varchar("contract", { length: 42 }).notNull(),
 	group: varchar("group", { length: 66 }).notNull(),
+	obligationId: varchar("obligation_id", { length: 66 }).notNull(),
 	lower: numeric("lower", {
 		precision: 78,
 		scale: 0
@@ -5316,7 +5502,8 @@ const lots = s.table(EnumTableName.LOTS, {
 			table.chainId,
 			table.user,
 			table.contract,
-			table.group
+			table.group,
+			table.obligationId
 		],
 		name: "lots_pk"
 	}),
@@ -5352,6 +5539,7 @@ const offsets = s.table(EnumTableName.OFFSETS, {
 	user: varchar("user", { length: 42 }).notNull(),
 	contract: varchar("contract", { length: 42 }).notNull(),
 	group: varchar("group", { length: 66 }).notNull(),
+	obligationId: varchar("obligation_id", { length: 66 }).notNull(),
 	value: numeric("value", {
 		precision: 78,
 		scale: 0
@@ -5361,7 +5549,8 @@ const offsets = s.table(EnumTableName.OFFSETS, {
 		table.chainId,
 		table.user,
 		table.contract,
-		table.group
+		table.group,
+		table.obligationId
 	],
 	name: "offsets_pk"
 }), foreignKey({
@@ -5952,6 +6141,7 @@ function decodeCallbacks(parameters) {
 			positionContract: loanToken,
 			positionUser: offer.maker,
 			group: offer.group,
+			obligationId: obligationId(offer),
 			size: offer.assets
 		});
 		callbacks.push({
@@ -7354,6 +7544,7 @@ function create$14(config) {
 	return {
 		get: async (parameters) => {
 			const { side, obligationId, cursor: cursorString, limit = DEFAULT_LIMIT$3 } = parameters;
+			const tickSortDirection = side === "sell" ? "asc" : "desc";
 			const inputCursor = LevelCursor.decode(cursorString, logger);
 			if (cursorString != null && inputCursor === null) return {
 				levels: [],
@@ -7368,23 +7559,23 @@ function create$14(config) {
 				cursor: inputCursor?.offersCursor ?? void 0,
 				limit: fetchLimit
 			});
-			const priceMap = /* @__PURE__ */ new Map();
+			const tickMap = /* @__PURE__ */ new Map();
 			for (const row of rows) {
-				const priceKey = row.price.toString();
-				const existing = priceMap.get(priceKey);
+				const existing = tickMap.get(row.tick);
 				if (existing) {
 					existing.assets += row.takeable;
 					existing.count += 1;
-				} else priceMap.set(priceKey, {
+				} else tickMap.set(row.tick, {
 					assets: row.takeable,
 					count: 1
 				});
 			}
-			const levels = Array.from(priceMap.entries()).map(([price, data]) => ({
-				price: BigInt(price),
-				assets: data.assets,
-				count: data.count
+			const levels = Array.from(tickMap.entries()).map(([tick, level]) => ({
+				tick,
+				assets: level.assets,
+				count: level.count
 			}));
+			levels.sort((a, b) => tickSortDirection === "asc" ? a.tick - b.tick : b.tick - a.tick);
 			const paginatedLevels = levels.slice(0, limit);
 			const hasMore = levels.length > limit || offersNextCursor !== null;
 			const lastLevel = paginatedLevels[paginatedLevels.length - 1];
@@ -7430,14 +7621,14 @@ async function _getOffers(db, params) {
         AND (s.code IS NULL OR s.code = ${Status.VALID})
       ORDER BY
         o.group_chain_id, o.group_maker, o."group_group",
-        o.price::numeric ${priceSortDirection === "asc" ? sql`ASC` : sql`DESC`}, o.block_number ASC, o.assets DESC, o.hash ASC
+        o.tick ${priceSortDirection === "asc" ? sql`ASC` : sql`DESC`}, o.block_number ASC, o.assets DESC, o.hash ASC
     ),
     enriched AS (
       SELECT
         w.*,
         g.consumed, g.chain_id, obl.loan_token,
         CASE WHEN ${priceSortDirection === "asc" ? sql`TRUE` : sql`FALSE`}
-          THEN w.price::numeric ELSE -w.price::numeric END AS price_norm,
+          THEN w.tick ELSE -w.tick END AS tick_norm,
         w.block_number AS block_norm,
         -w.assets AS assets_norm,
         w.hash AS hash_norm
@@ -7454,33 +7645,35 @@ async function _getOffers(db, params) {
       FROM enriched e
       ${cursor != null ? sql`
         WHERE
-        (e.price_norm, e.block_norm, e.assets_norm, e.hash_norm)
+        (e.tick_norm, e.block_norm, e.assets_norm, e.hash_norm)
           > (
               CASE WHEN ${priceSortDirection === "asc" ? sql`TRUE` : sql`FALSE`}
-                THEN ${cursor.price}::numeric ELSE -${cursor.price}::numeric END,
+                THEN ${cursor.tick}::integer ELSE -${cursor.tick}::integer END,
               ${cursor.blockNumber},
               -${cursor.assets}::numeric,
               ${cursor.hash}
             )` : sql``}
-      ORDER BY e.price::numeric ${priceSortDirection === "asc" ? sql`ASC` : sql`DESC`}, e.block_number ASC, e.assets DESC, e.hash ASC
+      ORDER BY e.tick ${priceSortDirection === "asc" ? sql`ASC` : sql`DESC`}, e.block_number ASC, e.assets DESC, e.hash ASC
       LIMIT ${limit}
     ),
-    -- Compute sum of offsets per position
+    -- Compute sum of offsets per position and obligation
     position_offsets AS (
       SELECT
         chain_id,
         "user",
         contract,
+        obligation_id,
         SUM(value::numeric) AS total_offset
       FROM ${offsets}
-      GROUP BY chain_id, "user", contract
+      GROUP BY chain_id, "user", contract, obligation_id
     ),
-    -- Compute position_consumed: sum of consumed from all groups with lots on each position (converted to lot terms)
+    -- Compute position_consumed: sum of consumed from all groups with lots on each position+obligation (converted to lot terms)
     position_consumed AS (
       SELECT
         l.chain_id,
         l.contract,
         l."user",
+        l.obligation_id,
         SUM(
           CASE
             WHEN wo.assets::numeric > 0
@@ -7497,7 +7690,7 @@ async function _getOffers(db, params) {
         ON wo.group_chain_id = g.chain_id
         AND LOWER(wo.group_maker) = LOWER(g.maker)
         AND wo.group_group = g."group"
-      GROUP BY l.chain_id, l.contract, l."user"
+      GROUP BY l.chain_id, l.contract, l."user", l.obligation_id
     ),
     -- Compute callback contributions with lot balance
     callback_contributions AS (
@@ -7505,7 +7698,7 @@ async function _getOffers(db, params) {
         p.hash,
         p.obligation_id,
         p.assets,
-        p.price,
+        p.tick,
         p.obligation_units,
         p.obligation_shares,
         p.maturity,
@@ -7550,6 +7743,7 @@ async function _getOffers(db, params) {
         AND LOWER(l.contract) = LOWER(c.position_contract)
         AND LOWER(l."user") = LOWER(c.position_user)
         AND l."group" = p.group_group
+        AND l.obligation_id = p.obligation_id
       LEFT JOIN ${positions} pos
         ON pos.chain_id = c.position_chain_id
         AND LOWER(pos.contract) = LOWER(c.position_contract)
@@ -7558,10 +7752,12 @@ async function _getOffers(db, params) {
         ON pos_offsets.chain_id = c.position_chain_id
         AND LOWER(pos_offsets.contract) = LOWER(c.position_contract)
         AND LOWER(pos_offsets."user") = LOWER(c.position_user)
+        AND pos_offsets.obligation_id = p.obligation_id
       LEFT JOIN position_consumed pc
         ON pc.chain_id = c.position_chain_id
         AND LOWER(pc.contract) = LOWER(c.position_contract)
         AND LOWER(pc."user") = LOWER(c.position_user)
+        AND pc.obligation_id = p.obligation_id
     ),
     -- Compute contribution per callback in loan terms (loan token only — collateral positions are not indexed)
     callback_loan_contribution AS (
@@ -7579,7 +7775,7 @@ async function _getOffers(db, params) {
         hash,
         obligation_id,
         assets,
-        price,
+        tick,
         obligation_units,
         obligation_shares,
         maturity,
@@ -7605,13 +7801,13 @@ async function _getOffers(db, params) {
         WHERE clc.callback_id IS NOT NULL
         ORDER BY clc.hash, clc.position_chain_id, clc.position_contract, clc.position_user, clc.contribution_in_loan DESC
       ) deduped
-      GROUP BY hash, obligation_id, assets, price, obligation_units, obligation_shares, maturity, expiry, start, group_group, buy,
+      GROUP BY hash, obligation_id, assets, tick, obligation_units, obligation_shares, maturity, expiry, start, group_group, buy,
                callback_address, callback_data, block_number, group_chain_id, group_maker,
                consumed, chain_id, loan_token, session
       UNION ALL
       -- Sell offers without callbacks: collateral positions not indexed, takeable = assets - consumed
       SELECT
-        p.hash, p.obligation_id, p.assets, p.price,
+        p.hash, p.obligation_id, p.assets, p.tick,
         p.obligation_units, p.obligation_shares,
         p.maturity, p.expiry, p.start, p.group_group,
         p.buy, p.callback_address, p.callback_data,
@@ -7633,7 +7829,7 @@ async function _getOffers(db, params) {
       oc.obligation_units,
       oc.obligation_shares,
       oc.consumed,
-      oc.price,
+      oc.tick,
       oc.maturity,
       oc.expiry,
       oc.start,
@@ -7665,7 +7861,7 @@ async function _getOffers(db, params) {
       ))
     END > 0
     ORDER BY
-      oc.price::numeric ${priceSortDirection === "asc" ? sql`ASC` : sql`DESC`},
+      oc.tick ${priceSortDirection === "asc" ? sql`ASC` : sql`DESC`},
       oc.block_number ASC,
       oc.assets DESC,
       oc.hash ASC;
@@ -7678,7 +7874,7 @@ async function _getOffers(db, params) {
 				assets: BigInt(row.assets),
 				obligationUnits: BigInt(row.obligation_units ?? 0),
 				obligationShares: BigInt(row.obligation_shares ?? 0),
-				price: BigInt(row.price),
+				tick: row.tick,
 				maturity: row.maturity,
 				expiry: row.expiry,
 				start: row.start,
@@ -7710,7 +7906,7 @@ let Cursor;
 	function encode(row, totalReturned, now, side) {
 		return Buffer.from(JSON.stringify({
 			side,
-			price: row.price.toString(),
+			tick: row.tick,
 			blockNumber: row.blockNumber,
 			assets: row.assets.toString(),
 			hash: row.hash,
@@ -7721,10 +7917,9 @@ let Cursor;
 	_Cursor.encode = encode;
 	function decode(cursorString, logger) {
 		if (cursorString == null) return null;
-		const isNumericString = (value) => typeof value === "string" && /^-?\d+$/.test(value);
 		try {
 			const v = JSON.parse(Buffer.from(cursorString, "base64url").toString("utf8"));
-			if ((v?.side === "buy" || v?.side === "sell") && isNumericString(v?.price) && typeof v?.blockNumber === "number" && Number.isInteger(v.blockNumber) && isNumericString(v?.assets) && isHex(v?.hash) && typeof v?.totalReturned === "number" && Number.isInteger(v.totalReturned) && typeof v?.now === "number" && Number.isInteger(v.now)) return v;
+			if ((v?.side === "buy" || v?.side === "sell") && typeof v?.tick === "number" && Number.isInteger(v.tick) && typeof v?.blockNumber === "number" && Number.isInteger(v.blockNumber) && typeof v?.assets === "string" && /^-?\d+$/.test(v.assets) && isHex(v?.hash) && typeof v?.totalReturned === "number" && Number.isInteger(v.totalReturned) && typeof v?.now === "number" && Number.isInteger(v.now)) return v;
 			throw new Error("Invalid cursor");
 		} catch {
 			logger.error({
@@ -7742,7 +7937,7 @@ let LevelCursor;
 	function encode(lastLevel, offersCursor, side, now) {
 		return Buffer.from(JSON.stringify({
 			side,
-			lastPrice: lastLevel.price.toString(),
+			lastTick: lastLevel.tick,
 			now,
 			offersCursor
 		})).toString("base64url");
@@ -7750,10 +7945,9 @@ let LevelCursor;
 	_LevelCursor.encode = encode;
 	function decode(cursorString, logger) {
 		if (cursorString == null) return null;
-		const isNumericString = (value) => typeof value === "string" && /^-?\d+$/.test(value);
 		try {
 			const v = JSON.parse(Buffer.from(cursorString, "base64url").toString("utf8"));
-			if ((v?.side === "buy" || v?.side === "sell") && isNumericString(v?.lastPrice) && typeof v?.now === "number" && Number.isInteger(v.now) && (v?.offersCursor === null || typeof v?.offersCursor === "string")) return v;
+			if ((v?.side === "buy" || v?.side === "sell") && typeof v?.lastTick === "number" && Number.isInteger(v.lastTick) && typeof v?.now === "number" && Number.isInteger(v.now) && (v?.offersCursor === null || typeof v?.offersCursor === "string")) return v;
 			throw new Error("Invalid book cursor");
 		} catch {
 			logger.error({
@@ -7911,31 +8105,33 @@ function create$11(db) {
 function create$10(db) {
 	return {
 		get: async (parameters) => {
-			const { chainId, user, contract, group } = parameters ?? {};
+			const { chainId, user, contract, group, obligationId } = parameters ?? {};
 			const conditions = [];
 			if (chainId !== void 0) conditions.push(eq(lots.chainId, chainId));
 			if (user !== void 0) conditions.push(eq(lots.user, user.toLowerCase()));
 			if (contract !== void 0) conditions.push(eq(lots.contract, contract.toLowerCase()));
 			if (group !== void 0) conditions.push(eq(lots.group, group));
+			if (obligationId !== void 0) conditions.push(eq(lots.obligationId, obligationId));
 			return (await db.select().from(lots).where(conditions.length > 0 ? and(...conditions) : void 0)).map((row) => ({
 				chainId: row.chainId,
 				user: row.user,
 				contract: row.contract,
 				group: row.group,
+				obligationId: row.obligationId,
 				lower: BigInt(row.lower),
 				upper: BigInt(row.upper)
 			}));
 		},
 		create: async (parameters) => {
 			if (parameters.length === 0) return;
-			const lotsByPositionGroup = /* @__PURE__ */ new Map();
+			const lotsByKey = /* @__PURE__ */ new Map();
 			for (const offer of parameters) {
-				const key = `${offer.positionChainId}-${offer.positionContract}-${offer.positionUser}-${offer.group}`.toLowerCase();
-				const existing = lotsByPositionGroup.get(key);
-				if (!existing || offer.size > existing.size) lotsByPositionGroup.set(key, offer);
+				const key = `${offer.positionChainId}-${offer.positionContract}-${offer.positionUser}-${offer.group}-${offer.obligationId}`.toLowerCase();
+				const existing = lotsByKey.get(key);
+				if (!existing || offer.size > existing.size) lotsByKey.set(key, offer);
 			}
-			for (const offer of lotsByPositionGroup.values()) if ((await db.select().from(lots).where(and(eq(lots.chainId, offer.positionChainId), eq(lots.contract, offer.positionContract.toLowerCase()), eq(lots.user, offer.positionUser.toLowerCase()), eq(lots.group, offer.group.toLowerCase()))).limit(1)).length === 0) {
-				const maxUpperResult = await db.select({ maxUpper: sql`COALESCE(MAX(${lots.upper}::numeric), 0)` }).from(lots).where(and(eq(lots.chainId, offer.positionChainId), eq(lots.contract, offer.positionContract.toLowerCase()), eq(lots.user, offer.positionUser.toLowerCase())));
+			for (const offer of lotsByKey.values()) if ((await db.select().from(lots).where(and(eq(lots.chainId, offer.positionChainId), eq(lots.contract, offer.positionContract.toLowerCase()), eq(lots.user, offer.positionUser.toLowerCase()), eq(lots.group, offer.group.toLowerCase()), eq(lots.obligationId, offer.obligationId.toLowerCase()))).limit(1)).length === 0) {
+				const maxUpperResult = await db.select({ maxUpper: sql`COALESCE(MAX(${lots.upper}::numeric), 0)` }).from(lots).where(and(eq(lots.chainId, offer.positionChainId), eq(lots.contract, offer.positionContract.toLowerCase()), eq(lots.user, offer.positionUser.toLowerCase()), eq(lots.obligationId, offer.obligationId.toLowerCase())));
 				const newLower = BigInt(maxUpperResult[0]?.maxUpper ?? "0");
 				const newUpper = newLower + offer.size;
 				await db.insert(lots).values({
@@ -7943,6 +8139,7 @@ function create$10(db) {
 					user: offer.positionUser.toLowerCase(),
 					contract: offer.positionContract.toLowerCase(),
 					group: offer.group.toLowerCase(),
+					obligationId: offer.obligationId.toLowerCase(),
 					lower: newLower.toString(),
 					upper: newUpper.toString()
 				});
@@ -8059,7 +8256,7 @@ function create$8(config) {
 				assets: offers.assets,
 				obligationUnits: offers.obligationUnits,
 				obligationShares: offers.obligationShares,
-				price: offers.price,
+				tick: offers.tick,
 				maturity: offers.maturity,
 				expiry: offers.expiry,
 				start: offers.start,
@@ -8079,7 +8276,7 @@ function create$8(config) {
 					assets: BigInt(row.assets),
 					obligationUnits: BigInt(row.obligationUnits),
 					obligationShares: BigInt(row.obligationShares),
-					price: BigInt(row.price),
+					tick: row.tick,
 					maturity: from$16(row.maturity),
 					expiry: row.expiry,
 					start: row.start,
@@ -8161,8 +8358,8 @@ function create$8(config) {
 			const now$2 = now();
 			const query = ({ side }) => db.selectDistinctOn([offers.obligationId], {
 				obligationId: offers.obligationId,
-				price: offers.price
-			}).from(offers).innerJoin(groups, and(eq(offers.groupChainId, groups.chainId), eq(offers.groupMaker, groups.maker), eq(offers.group, groups.group))).leftJoin(validations, eq(offers.hash, validations.offerHash)).leftJoin(status, eq(validations.statusId, status.id)).where(and(inArray(offers.obligationId, obligationIds), eq(offers.buy, side === "buy"), gte(offers.expiry, now$2), gte(offers.maturity, now$2), lte(offers.start, now$2), sql`(${status.code} IS NULL OR ${status.code} = ${Status.VALID})`)).orderBy(offers.obligationId, side === "buy" ? sql`${offers.price}::numeric ASC` : sql`${offers.price}::numeric DESC`);
+				price: offers.tick
+			}).from(offers).innerJoin(groups, and(eq(offers.groupChainId, groups.chainId), eq(offers.groupMaker, groups.maker), eq(offers.group, groups.group))).leftJoin(validations, eq(offers.hash, validations.offerHash)).leftJoin(status, eq(validations.statusId, status.id)).where(and(inArray(offers.obligationId, obligationIds), eq(offers.buy, side === "buy"), gte(offers.expiry, now$2), gte(offers.maturity, now$2), lte(offers.start, now$2), sql`(${status.code} IS NULL OR ${status.code} = ${Status.VALID})`)).orderBy(offers.obligationId, side === "buy" ? sql`${offers.tick} ASC` : sql`${offers.tick} DESC`);
 			const [bestBuys, bestSells] = await Promise.all([query({ side: "buy" }), query({ side: "sell" })]);
 			const quotes = /* @__PURE__ */ new Map();
 			for (const row of bestSells) quotes.set(row.obligationId, {
@@ -8197,17 +8394,19 @@ function create$8(config) {
 //#region src/database/domains/Offsets.ts
 function create$7(db) {
 	return { get: async (parameters) => {
-		const { chainId, user, contract, group } = parameters ?? {};
+		const { chainId, user, contract, group, obligationId } = parameters ?? {};
 		const conditions = [];
 		if (chainId !== void 0) conditions.push(eq(offsets.chainId, chainId));
 		if (user !== void 0) conditions.push(eq(offsets.user, user.toLowerCase()));
 		if (contract !== void 0) conditions.push(eq(offsets.contract, contract.toLowerCase()));
 		if (group !== void 0) conditions.push(eq(offsets.group, group));
+		if (obligationId !== void 0) conditions.push(eq(offsets.obligationId, obligationId));
 		return (await db.select().from(offsets).where(conditions.length > 0 ? and(...conditions) : void 0)).map((row) => ({
 			chainId: row.chainId,
 			user: row.user,
 			contract: row.contract,
 			group: row.group,
+			obligationId: row.obligationId,
 			value: BigInt(row.value)
 		}));
 	} };
@@ -8357,7 +8556,8 @@ const create$5 = (db) => {
 				if (!parsed.chainId || !parsed.contract) throw new Error("Invalid cursor format");
 				cursor = {
 					chainId: parsed.chainId,
-					contract: parsed.contract
+					contract: parsed.contract,
+					obligationId: parsed.obligationId ?? null
 				};
 			}
 			const raw = await db.execute(sql`
@@ -8366,16 +8566,18 @@ const create$5 = (db) => {
             chain_id,
             "user",
             contract,
+            obligation_id,
             SUM(value::numeric) AS total_offset
           FROM ${offsets}
           WHERE LOWER("user") = LOWER(${user})
-          GROUP BY chain_id, "user", contract
+          GROUP BY chain_id, "user", contract, obligation_id
         ),
         position_consumed AS (
           SELECT
             l.chain_id,
             l.contract,
             l."user",
+            l.obligation_id,
             SUM(
               CASE
                 WHEN offer_agg.assets > 0
@@ -8401,50 +8603,64 @@ const create$5 = (db) => {
             AND LOWER(offer_agg.group_maker) = LOWER(g.maker)
             AND offer_agg."group_group" = g."group"
           WHERE LOWER(l."user") = LOWER(${user})
-          GROUP BY l.chain_id, l.contract, l."user"
+          GROUP BY l.chain_id, l.contract, l."user", l.obligation_id
         ),
         position_max_lot AS (
           SELECT
             chain_id,
             contract,
             "user",
+            obligation_id,
             MAX(upper::numeric) AS max_upper
           FROM ${lots}
           WHERE LOWER("user") = LOWER(${user})
-          GROUP BY chain_id, contract, "user"
+          GROUP BY chain_id, contract, "user", obligation_id
+        ),
+        per_obligation AS (
+          SELECT
+            pml.chain_id,
+            pml.contract,
+            pml."user",
+            pml.obligation_id,
+            GREATEST(0,
+              COALESCE(pml.max_upper, 0)
+              - COALESCE(po.total_offset, 0)
+              - COALESCE(pc.consumed, 0)
+            )::text AS reserved_balance
+          FROM position_max_lot pml
+          LEFT JOIN position_offsets po
+            ON po.chain_id = pml.chain_id
+            AND LOWER(po.contract) = LOWER(pml.contract)
+            AND LOWER(po."user") = LOWER(pml."user")
+            AND po.obligation_id = pml.obligation_id
+          LEFT JOIN position_consumed pc
+            ON pc.chain_id = pml.chain_id
+            AND LOWER(pc.contract) = LOWER(pml.contract)
+            AND LOWER(pc."user") = LOWER(pml."user")
+            AND pc.obligation_id = pml.obligation_id
         )
         SELECT
           p.chain_id,
           p.contract,
           p."user",
           p.block_number,
-          GREATEST(0,
-            COALESCE(pml.max_upper, 0)
-            - COALESCE(po.total_offset, 0)
-            - COALESCE(pc.consumed, 0)
-          )::text AS reserved_balance
+          po.obligation_id,
+          COALESCE(po.reserved_balance, '0') AS reserved_balance
         FROM ${positions} p
-        LEFT JOIN position_offsets po
+        LEFT JOIN per_obligation po
           ON po.chain_id = p.chain_id
           AND LOWER(po.contract) = LOWER(p.contract)
           AND LOWER(po."user") = LOWER(p."user")
-        LEFT JOIN position_consumed pc
-          ON pc.chain_id = p.chain_id
-          AND LOWER(pc.contract) = LOWER(p.contract)
-          AND LOWER(pc."user") = LOWER(p."user")
-        LEFT JOIN position_max_lot pml
-          ON pml.chain_id = p.chain_id
-          AND LOWER(pml.contract) = LOWER(p.contract)
-          AND LOWER(pml."user") = LOWER(p."user")
         WHERE LOWER(p."user") = LOWER(${user})
           AND p."user" != ${zeroAddress}
-          ${cursor !== null ? sql`AND (p.chain_id, p.contract) > (${cursor.chainId}, ${cursor.contract})` : sql``}
-        ORDER BY p.chain_id ASC, p.contract ASC
+          ${cursor !== null ? sql`AND (p.chain_id, p.contract, COALESCE(po.obligation_id, '')) > (${cursor.chainId}, ${cursor.contract}, ${cursor.obligationId ?? ""})` : sql``}
+        ORDER BY p.chain_id ASC, p.contract ASC, po.obligation_id ASC NULLS FIRST
         LIMIT ${limit}
       `);
 			const nextCursor = raw.rows.length === limit ? Buffer.from(JSON.stringify({
 				chainId: raw.rows[raw.rows.length - 1].chain_id.toString(),
-				contract: raw.rows[raw.rows.length - 1].contract
+				contract: raw.rows[raw.rows.length - 1].contract,
+				obligationId: raw.rows[raw.rows.length - 1].obligation_id
 			})).toString("base64url") : null;
 			return {
 				positions: raw.rows.map((row) => ({
@@ -8452,6 +8668,7 @@ const create$5 = (db) => {
 					contract: row.contract,
 					user: row.user,
 					blockNumber: row.block_number,
+					obligationId: row.obligation_id,
 					reserved: BigInt(row.reserved_balance.split(".")[0] ?? "0")
 				})),
 				nextCursor
@@ -8826,6 +9043,7 @@ function augmentWithDomains(base, chainRegistry) {
 	return wrapped;
 }
 const InMemoryDbMap = /* @__PURE__ */ new Map();
+const LEGACY_SCHEMA_START_MINOR = 7;
 /**
 * Connect to the database.
 * @notice If no connection string is provided, an in-process PGLite database is created.
@@ -8880,9 +9098,26 @@ function applyMigrations(kind, driver) {
 async function preMigrate(driver) {
 	const tracer = getTracer("db.preMigrate");
 	await startActiveSpan(tracer, "db.preMigrate", async () => {
-		await driver.execute(`create schema if not exists "${VERSION}"`);
+		const schemaNames = getSchemaNamesForMigration(VERSION);
+		for (const schemaName of schemaNames) await driver.execute(`create schema if not exists "${schemaName}"`);
 	});
 }
+/**
+* Build the list of router schemas that should exist before running migrations.
+* @param version - Current schema version (e.g. `router_v1.8`).
+* @returns Ordered schema names from `router_v1.7` to current, or just current if parsing fails.
+*/
+function getSchemaNamesForMigration(version) {
+	const parsed = /^router_v(?<major>\d+)\.(?<minor>\d+)$/.exec(version);
+	if (!parsed?.groups?.major || !parsed.groups.minor) return [version];
+	const major = Number.parseInt(parsed.groups.major, 10);
+	const currentMinor = Number.parseInt(parsed.groups.minor, 10);
+	if (!Number.isInteger(major) || !Number.isInteger(currentMinor)) return [version];
+	if (currentMinor < LEGACY_SCHEMA_START_MINOR) return [version];
+	const schemaNames = [];
+	for (let minor = LEGACY_SCHEMA_START_MINOR; minor <= currentMinor; minor += 1) schemaNames.push(`router_v${major}.${minor}`);
+	return schemaNames;
+}
 async function postMigrate(driver) {
 	const tracer = getTracer("db.postMigrate");
 	await startActiveSpan(tracer, "db.postMigrate", async () => {
@@ -9152,15 +9387,16 @@ async function postMigrate(driver) {
     RETURNS trigger
     LANGUAGE plpgsql AS $$
     BEGIN
-      INSERT INTO "${VERSION}"."offsets" (chain_id, "user", contract, "group", value)
+      INSERT INTO "${VERSION}"."offsets" (chain_id, "user", contract, "group", obligation_id, value)
       VALUES (
         OLD.chain_id,
         OLD."user",
         OLD.contract,
         OLD."group",
+        OLD.obligation_id,
         OLD.upper::numeric - OLD.lower::numeric
       )
-      ON CONFLICT (chain_id, "user", contract, "group") DO NOTHING;
+      ON CONFLICT (chain_id, "user", contract, "group", obligation_id) DO NOTHING;
       RETURN OLD;
     END;
     $$;
@@ -9542,12 +9778,34 @@ async function getBook(params, db) {
 	if (!result.success) return failure(result.error);
 	const query = result.data;
 	try {
+		logger.debug({
+			service: "api_controller",
+			endpoint: "get_book",
+			msg: "Loading book levels",
+			obligation_id: query.obligation_id,
+			side: query.side,
+			limit: query.limit ?? null,
+			has_cursor: query.cursor != null
+		});
 		const { levels, nextCursor } = await db.book.get({
 			side: query.side,
 			obligationId: query.obligation_id,
 			cursor: query.cursor,
 			limit: query.limit
 		});
+		const firstLevel = levels[0];
+		logger.debug({
+			service: "api_controller",
+			endpoint: "get_book",
+			msg: "Loaded book levels",
+			obligation_id: query.obligation_id,
+			side: query.side,
+			levels_count: levels.length,
+			has_next_cursor: nextCursor != null,
+			first_level_tick: firstLevel?.tick ?? null,
+			first_level_assets: firstLevel?.assets.toString() ?? null,
+			first_level_count: firstLevel?.count ?? null
+		});
 		return success({
 			data: levels.map(from$6),
 			cursor: nextCursor
@@ -10049,16 +10307,57 @@ async function getOffersQuery(db, parameters) {
         '[]'::jsonb
       )`.as("collaterals") }).from(obligationCollateralsV2).innerJoin(oracles, sql`${obligationCollateralsV2.oracleChainId} = ${oracles.chainId}
              AND ${obligationCollateralsV2.oracleAddress} = ${oracles.address}`).where(eq(obligationCollateralsV2.obligationId, offers.obligationId)).as("collaterals_lateral");
-	const availableLateral = db.select({ available: sql`COALESCE(SUM(
-            CASE
-              WHEN ${positions.asset} IS NULL THEN 0
-              ELSE
-                CASE
-                  WHEN ${callbacks.amount} IS NULL THEN COALESCE(${positions.balance}, 0)::numeric
-                  ELSE LEAST(${callbacks.amount}::numeric, COALESCE(${positions.balance}, 0)::numeric)
-                END
-            END
-          ), 0)`.as("available") }).from(offersCallbacks).innerJoin(callbacks, eq(offersCallbacks.callbackId, callbacks.id)).innerJoin(positions, and(eq(callbacks.positionChainId, positions.chainId), eq(callbacks.positionContract, positions.contract), eq(callbacks.positionUser, positions.user))).where(eq(offersCallbacks.offerHash, offers.hash)).as("available_lateral");
+	const lotBalanceExpr = sql`GREATEST(0, LEAST(
+      COALESCE(${positions.balance}, 0)::numeric
+        + COALESCE((
+            SELECT SUM(${offsets.value}::numeric)
+            FROM ${offsets}
+            WHERE ${offsets.chainId} = ${callbacks.positionChainId}
+              AND LOWER(${offsets.contract}) = LOWER(${callbacks.positionContract})
+              AND LOWER(${offsets.user}) = LOWER(${callbacks.positionUser})
+          ), 0)
+        - COALESCE(${lots.lower}::numeric, 0),
+      (COALESCE(${lots.upper}::numeric, 0) - COALESCE(${lots.lower}::numeric, 0))
+        - CASE
+            WHEN ${offers.assets}::numeric > 0
+            THEN COALESCE(${groups.consumed}::numeric, 0)
+              * (COALESCE(${lots.upper}::numeric, 0) - COALESCE(${lots.lower}::numeric, 0))
+              / ${offers.assets}::numeric
+            ELSE 0
+          END
+    ))`;
+	const contributionExpr = sql`CASE
+      WHEN ${positions.asset} IS NULL OR ${lots.lower} IS NULL THEN 0
+      ELSE LEAST(COALESCE(${callbacks.amount}::numeric, ${lotBalanceExpr}), ${lotBalanceExpr})
+    END`;
+	const availableExpr = sql`COALESCE((
+      SELECT SUM(deduped.contribution)
+      FROM (
+        SELECT DISTINCT ON (
+          ${callbacks.positionChainId},
+          LOWER(${callbacks.positionContract}),
+          LOWER(${callbacks.positionUser})
+        )
+          ${contributionExpr} AS contribution
+        FROM ${offersCallbacks}
+        INNER JOIN ${callbacks} ON ${offersCallbacks.callbackId} = ${callbacks.id}
+        LEFT JOIN ${positions}
+          ON ${positions.chainId} = ${callbacks.positionChainId}
+          AND LOWER(${positions.contract}) = LOWER(${callbacks.positionContract})
+          AND LOWER(${positions.user}) = LOWER(${callbacks.positionUser})
+        LEFT JOIN ${lots}
+          ON ${lots.chainId} = ${callbacks.positionChainId}
+          AND LOWER(${lots.contract}) = LOWER(${callbacks.positionContract})
+          AND LOWER(${lots.user}) = LOWER(${callbacks.positionUser})
+          AND LOWER(${lots.group}) = LOWER(${offers.group})
+        WHERE ${offersCallbacks.offerHash} = ${offers.hash}
+        ORDER BY
+          ${callbacks.positionChainId},
+          LOWER(${callbacks.positionContract}),
+          LOWER(${callbacks.positionUser}),
+          ${contributionExpr} DESC
+      ) deduped
+    ), 0)`;
 	const rows = (await db.select({
 		hash: offers.hash,
 		maker: offers.groupMaker,
@@ -10066,7 +10365,7 @@ async function getOffersQuery(db, parameters) {
 		obligationUnits: offers.obligationUnits,
 		obligationShares: offers.obligationShares,
 		consumed: groups.consumed,
-		price: offers.price,
+		tick: offers.tick,
 		maturity: offers.maturity,
 		expiry: offers.expiry,
 		start: offers.start,
@@ -10079,22 +10378,22 @@ async function getOffersQuery(db, parameters) {
 		callbackData: offers.callbackData,
 		collaterals: collateralsLateral.collaterals,
 		blockNumber: offers.blockNumber,
-		available: sql`COALESCE(${availableLateral.available}::numeric, 0)`.as("available"),
+		available: sql`${availableExpr}::numeric`.as("available"),
 		takeable: sql`FLOOR(GREATEST(0,
             CASE WHEN ${offers.buy} = false
               THEN ${offers.assets}::numeric - ${groups.consumed}::numeric
               ELSE LEAST(
                 ${offers.assets}::numeric - ${groups.consumed}::numeric,
-                COALESCE(${availableLateral.available}::numeric, 0)
+                ${availableExpr}::numeric
               )
             END
           ))`.as("takeable")
-	}).from(offers).innerJoin(obligations, eq(offers.obligationId, obligations.obligationId)).innerJoin(groups, and(eq(offers.groupChainId, groups.chainId), eq(offers.groupMaker, groups.maker), eq(offers.group, groups.group))).innerJoinLateral(collateralsLateral, sql`true`).leftJoinLateral(availableLateral, sql`true`).where(and(cursor !== null && cursor !== void 0 ? gt(offers.hash, cursor) : void 0, maker !== void 0 ? eq(offers.groupMaker, maker.toLowerCase()) : void 0, gte(offers.expiry, now), gte(offers.maturity, now), maker === void 0 ? sql`GREATEST(0,
+	}).from(offers).innerJoin(obligations, eq(offers.obligationId, obligations.obligationId)).innerJoin(groups, and(eq(offers.groupChainId, groups.chainId), eq(offers.groupMaker, groups.maker), eq(offers.group, groups.group))).innerJoinLateral(collateralsLateral, sql`true`).where(and(cursor !== null && cursor !== void 0 ? gt(offers.hash, cursor) : void 0, maker !== void 0 ? eq(offers.groupMaker, maker.toLowerCase()) : void 0, gte(offers.expiry, now), gte(offers.maturity, now), maker === void 0 ? sql`GREATEST(0,
                   CASE WHEN ${offers.buy} = false
                     THEN ${offers.assets}::numeric - ${groups.consumed}::numeric
                     ELSE LEAST(
                       ${offers.assets}::numeric - ${groups.consumed}::numeric,
-                      COALESCE(${availableLateral.available}::numeric, 0)
+                      ${availableExpr}::numeric
                     )
                   END
                 ) > 0` : void 0)).orderBy(asc(offers.hash)).limit(limit)).map((row) => {
@@ -10104,7 +10403,7 @@ async function getOffersQuery(db, parameters) {
 			assets: BigInt(row.assets),
 			obligationUnits: BigInt(row.obligationUnits),
 			obligationShares: BigInt(row.obligationShares),
-			price: BigInt(row.price),
+			tick: row.tick,
 			maturity: from$16(row.maturity),
 			expiry: row.expiry,
 			start: row.start,
@@ -10761,6 +11060,7 @@ function buildOfferAssociationsFromOffers(parameters) {
 			positionContract: loanToken,
 			positionUser: offer.maker,
 			group: offer.group,
+			obligationId: obligationId(offer),
 			size: offer.assets
 		});
 	}