@morpho-dev/router 0.7.0 → 0.7.2

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.0";
+var version = "0.7.2";
 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: [
@@ -1483,73 +1483,10 @@ function create$20(parameters) {
 //#region src/core/Callback.ts
 let Type$1 = /* @__PURE__ */ function(Type) {
 	Type["BuyWithEmptyCallback"] = "buy_with_empty_callback";
-	Type["BuyERC20"] = "buy_erc20";
-	Type["BuyVaultV1Callback"] = "buy_vault_v1_callback";
-	Type["SellERC20Callback"] = "sell_erc20_callback";
+	Type["SellWithEmptyCallback"] = "sell_with_empty_callback";
 	return Type;
 }({});
 const isEmptyCallback = (offer) => offer.callback.data === "0x";
-function decode$1(type, data) {
-	switch (type) {
-		case Type$1.BuyERC20: return decodeBuyERC20(data);
-		case Type$1.BuyVaultV1Callback: return decodeBuyVaultV1Callback(data);
-		case Type$1.SellERC20Callback: return decodeSellERC20Callback(data);
-		default: throw new Error("Invalid callback type");
-	}
-}
-/**
-* Decodes BuyERC20 callback data into positions.
-* @param data - The ABI-encoded callback data containing token addresses and amounts.
-* @returns Array of positions with contract address and amount.
-* @throws If data is empty, malformed, or arrays have mismatched lengths.
-*/
-function decodeBuyERC20(data) {
-	if (!data || data === "0x") throw new Error("Empty callback data");
-	let tokens;
-	let amounts;
-	try {
-		[tokens, amounts] = decodeAbiParameters([{ type: "address[]" }, { type: "uint256[]" }], data);
-	} catch (_) {
-		throw new Error("Invalid BuyERC20 callback data");
-	}
-	if (tokens.length !== amounts.length) throw new Error("Mismatched array lengths");
-	return tokens.map((token, index) => ({
-		contract: token,
-		amount: amounts[index]
-	}));
-}
-function decodeBuyVaultV1Callback(data) {
-	if (!data || data === "0x") throw new Error("Empty callback data");
-	try {
-		const [vaults, amounts] = decodeAbiParameters([{ type: "address[]" }, { type: "uint256[]" }], data);
-		if (vaults.length !== amounts.length) throw new Error("Mismatched array lengths");
-		return vaults.map((v, i) => ({
-			contract: v,
-			amount: amounts[i]
-		}));
-	} catch (_) {
-		throw new Error("Invalid BuyVaultV1Callback callback data");
-	}
-}
-function decodeSellERC20Callback(data) {
-	if (!data || data === "0x") throw new Error("Empty callback data");
-	try {
-		const [collaterals, amounts] = decodeAbiParameters([{ type: "address[]" }, { type: "uint256[]" }], data);
-		if (collaterals.length !== amounts.length) throw new Error("Mismatched array lengths");
-		return collaterals.map((c, i) => ({
-			contract: c,
-			amount: amounts[i]
-		}));
-	} catch (_) {
-		throw new Error("Invalid SellERC20Callback callback data");
-	}
-}
-function encodeBuyVaultV1Callback(parameters) {
-	return encodeAbiParameters([{ type: "address[]" }, { type: "uint256[]" }], [parameters.vaults, parameters.amounts]);
-}
-function encodeSellERC20Callback(parameters) {
-	return encodeAbiParameters([{ type: "address[]" }, { type: "uint256[]" }], [parameters.collaterals, parameters.amounts]);
-}
 
 //#endregion
 //#region src/core/Maturity.ts
@@ -1671,26 +1608,6 @@ var InvalidOptionError$1 = class extends BaseError {
 
 //#endregion
 //#region src/gatekeeper/GateConfig.ts
-/**
-* Attempts to infer the configured callback type from a callback address on a chain.
-* Skips the empty callback type as it does not carry addresses.
-*
-* @param chain - Chain name for which to infer the callback type
-* @param address - Callback contract address
-* @returns The callback type when found, otherwise undefined
-*/
-function getCallbackType(chain, address) {
-	return configs[chain].callbacks?.find((c) => c.type !== Type$1.BuyWithEmptyCallback && c.addresses.includes(address?.toLowerCase()))?.type;
-}
-/**
-* Returns the list of allowed non-empty callback addresses for a chain.
-*
-* @param chain - Chain name
-* @returns Array of allowed callback addresses (lowercased). Empty when none configured
-*/
-const getCallbackAddresses = (chain) => {
-	return configs[chain].callbacks?.filter((c) => c.type !== Type$1.BuyWithEmptyCallback).flatMap((c) => c.addresses) ?? [];
-};
 const assets = {
 	[ChainId.ETHEREUM.toString()]: [
 		"0xA0b86991c6218b36c1d19D4a2e9Eb0cE3606eB48",
@@ -1762,63 +1679,19 @@ const oracles$1 = {
 };
 const configs = {
 	ethereum: {
-		callbacks: [
-			{
-				type: Type$1.BuyVaultV1Callback,
-				addresses: ["0x3333333333333333333333333333333333333333", "0x4444444444444444444444444444444444444444"],
-				vaultFactories: ["0xA9c3D3a366466Fa809d1Ae982Fb2c46E5fC41101", "0x1897A8997241C1cD4bD0698647e4EB7213535c24"]
-			},
-			{
-				type: Type$1.SellERC20Callback,
-				addresses: ["0x1111111111111111111111111111111111111111", "0x2222222222222222222222222222222222222222"]
-			},
-			{ type: Type$1.BuyWithEmptyCallback }
-		],
+		callbacks: [{ type: Type$1.BuyWithEmptyCallback }, { type: Type$1.SellWithEmptyCallback }],
 		maturities: [MaturityType.EndOfMonth, MaturityType.EndOfNextMonth]
 	},
 	base: {
-		callbacks: [
-			{
-				type: Type$1.BuyVaultV1Callback,
-				addresses: ["0x3333333333333333333333333333333333333333", "0x4444444444444444444444444444444444444444"],
-				vaultFactories: ["0xA9c3D3a366466Fa809d1Ae982Fb2c46E5fC41101", "0xFf62A7c278C62eD665133147129245053Bbf5918"]
-			},
-			{
-				type: Type$1.SellERC20Callback,
-				addresses: ["0x1111111111111111111111111111111111111111", "0x2222222222222222222222222222222222222222"]
-			},
-			{ type: Type$1.BuyWithEmptyCallback }
-		],
+		callbacks: [{ type: Type$1.BuyWithEmptyCallback }, { type: Type$1.SellWithEmptyCallback }],
 		maturities: [MaturityType.EndOfMonth, MaturityType.EndOfNextMonth]
 	},
 	"ethereum-virtual-testnet": {
-		callbacks: [
-			{
-				type: Type$1.BuyVaultV1Callback,
-				addresses: ["0x3333333333333333333333333333333333333333", "0x4444444444444444444444444444444444444444"],
-				vaultFactories: ["0xA9c3D3a366466Fa809d1Ae982Fb2c46E5fC41101", "0x1897A8997241C1cD4bD0698647e4EB7213535c24"]
-			},
-			{
-				type: Type$1.SellERC20Callback,
-				addresses: ["0x1111111111111111111111111111111111111111", "0x2222222222222222222222222222222222222222"]
-			},
-			{ type: Type$1.BuyWithEmptyCallback }
-		],
+		callbacks: [{ type: Type$1.BuyWithEmptyCallback }, { type: Type$1.SellWithEmptyCallback }],
 		maturities: [MaturityType.EndOfMonth, MaturityType.EndOfNextMonth]
 	},
 	anvil: {
-		callbacks: [
-			{
-				type: Type$1.BuyVaultV1Callback,
-				addresses: ["0x3333333333333333333333333333333333333333", "0x4444444444444444444444444444444444444444"],
-				vaultFactories: ["0xA9c3D3a366466Fa809d1Ae982Fb2c46E5fC41101", "0x1897A8997241C1cD4bD0698647e4EB7213535c24"]
-			},
-			{
-				type: Type$1.SellERC20Callback,
-				addresses: ["0x1111111111111111111111111111111111111111", "0x2222222222222222222222222222222222222222"]
-			},
-			{ type: Type$1.BuyWithEmptyCallback }
-		],
+		callbacks: [{ type: Type$1.BuyWithEmptyCallback }, { type: Type$1.SellWithEmptyCallback }],
 		maturities: [MaturityType.EndOfMonth, MaturityType.EndOfNextMonth]
 	}
 };
@@ -1841,6 +1714,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 = [{
@@ -2300,7 +2228,7 @@ function random(config) {
 	const chain = config?.chains ? config.chains[int(config.chains.length)] : chains$2.ethereum;
 	const loanToken = config?.loanTokens ? config.loanTokens[int(config.loanTokens.length)] : address();
 	const collateralCandidates = config?.collateralTokens ? config.collateralTokens.filter((a) => a !== loanToken) : [address()];
-	const collateralAsset = collateralCandidates[int(collateralCandidates.length)];
+	collateralCandidates[int(collateralCandidates.length)];
 	const maturityOption = weightedChoice([["end_of_month", 1], ["end_of_next_month", 1]]);
 	const maturity = config?.maturity ?? from$16(maturityOption);
 	const lltv = from$15(weightedChoice([
@@ -2327,21 +2255,10 @@ function random(config) {
 	const unit = BigInt(10) ** BigInt(loanTokenDecimals);
 	const amountBase = BigInt(100 + int(999901));
 	const assetsScaled = config?.assets ?? amountBase * unit;
-	const callbackBySide = (() => {
-		if (buy) return {
-			address: zeroAddress,
-			data: "0x"
-		};
-		const sellCallbackAddress = "0x3333333333333333333333333333333333333333";
-		const amount = assetsScaled * 1000000000000000000000n;
-		return {
-			address: sellCallbackAddress,
-			data: encodeSellERC20Callback({
-				collaterals: [collateralAsset],
-				amounts: [amount]
-			})
-		};
-	})();
+	const emptyCallback = {
+		address: zeroAddress,
+		data: "0x"
+	};
 	return from$12({
 		maker: config?.maker ?? address(),
 		assets: assetsScaled,
@@ -2360,7 +2277,7 @@ function random(config) {
 			...random$1(),
 			lltv
 		})).sort((a, b) => a.asset.localeCompare(b.asset)),
-		callback: config?.callback ?? callbackBySide
+		callback: config?.callback ?? emptyCallback
 	});
 }
 const weightedChoice = (pairs) => {
@@ -2514,6 +2431,94 @@ function obligationId(offer) {
 	}));
 }
 /**
+* ABI for the Take event emitted by the Morpho V2 contract.
+*/
+const takeEvent = {
+	type: "event",
+	name: "Take",
+	inputs: [
+		{
+			name: "caller",
+			type: "address",
+			indexed: false,
+			internalType: "address"
+		},
+		{
+			name: "id",
+			type: "bytes32",
+			indexed: true,
+			internalType: "bytes32"
+		},
+		{
+			name: "maker",
+			type: "address",
+			indexed: true,
+			internalType: "address"
+		},
+		{
+			name: "taker",
+			type: "address",
+			indexed: true,
+			internalType: "address"
+		},
+		{
+			name: "offerIsBuy",
+			type: "bool",
+			indexed: false,
+			internalType: "bool"
+		},
+		{
+			name: "buyerAssets",
+			type: "uint256",
+			indexed: false,
+			internalType: "uint256"
+		},
+		{
+			name: "sellerAssets",
+			type: "uint256",
+			indexed: false,
+			internalType: "uint256"
+		},
+		{
+			name: "obligationUnits",
+			type: "uint256",
+			indexed: false,
+			internalType: "uint256"
+		},
+		{
+			name: "obligationShares",
+			type: "uint256",
+			indexed: false,
+			internalType: "uint256"
+		},
+		{
+			name: "buyerIsLender",
+			type: "bool",
+			indexed: false,
+			internalType: "bool"
+		},
+		{
+			name: "sellerIsBorrower",
+			type: "bool",
+			indexed: false,
+			internalType: "bool"
+		},
+		{
+			name: "group",
+			type: "bytes32",
+			indexed: false,
+			internalType: "bytes32"
+		},
+		{
+			name: "consumed",
+			type: "uint256",
+			indexed: false,
+			internalType: "uint256"
+		}
+	],
+	anonymous: false
+};
+/**
 * ABI for the Consume event emitted by the Obligation contract.
 */
 const consumedEvent = {
@@ -2939,12 +2944,10 @@ const maturity = ({ maturities }) => single("maturity", `Validates that offer ma
 	const allowedMaturities = maturities.map((m) => from$16(m));
 	if (!allowedMaturities.includes(offer.maturity)) return { message: `Maturity must be end of current month (${allowedMaturities[0]}) or end of next month (${allowedMaturities[1]}). Got: ${offer.maturity}` };
 });
-const callback = ({ callbacks, allowedAddresses }) => single("callback", `Validates callbacks: buy empty callback is ${callbacks.includes(Type$1.BuyWithEmptyCallback) ? "allowed" : "not allowed"}; sell offers must use a non-empty callback; non-empty callbacks must target one of [${allowedAddresses.map((a) => a.toLowerCase()).join(", ")}]`, (offer) => {
-	if (isEmptyCallback(offer) && offer.buy && !callbacks?.find((c) => c === Type$1.BuyWithEmptyCallback)) return { message: "Buy offers with empty callback not allowed." };
-	if (isEmptyCallback(offer) && !offer.buy) return { message: "Sell offers require a non-empty callback." };
-	if (!isEmptyCallback(offer)) {
-		if (!allowedAddresses.includes(offer.callback.address?.toLowerCase())) return { message: `Callback address ${offer.callback.address} is not allowed.` };
-	}
+const callback = ({ callbacks }) => single("callback", `Validates callbacks: buy empty callback is ${callbacks.includes(Type$1.BuyWithEmptyCallback) ? "allowed" : "not allowed"}; sell empty callback is ${callbacks.includes(Type$1.SellWithEmptyCallback) ? "allowed" : "not allowed"}; non-empty callbacks are rejected`, (offer) => {
+	if (!isEmptyCallback(offer)) return { message: "Non-empty callbacks are not supported." };
+	if (isEmptyCallback(offer) && offer.buy && !callbacks.includes(Type$1.BuyWithEmptyCallback)) return { message: "Buy offers with empty callback not allowed." };
+	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.
@@ -3009,12 +3012,8 @@ const morphoRules = (chains) => {
 		chains$1({ chains }),
 		maturity({ maturities: [MaturityType.EndOfMonth, MaturityType.EndOfNextMonth] }),
 		callback({
-			callbacks: [
-				Type$1.BuyWithEmptyCallback,
-				Type$1.BuyVaultV1Callback,
-				Type$1.SellERC20Callback
-			],
-			allowedAddresses: chains.flatMap((c) => getCallbackAddresses(c.name))
+			callbacks: [Type$1.BuyWithEmptyCallback, Type$1.SellWithEmptyCallback],
+			allowedAddresses: []
 		}),
 		token({ assetsByChainId }),
 		oracle({ oraclesByChainId })
@@ -3031,25 +3030,13 @@ const morphoRules = (chains) => {
 function buildConfigRules(chains) {
 	const rules = [];
 	for (const chain of chains) {
-		const config = configs[chain.name];
-		const maturities = config.maturities ?? [];
+		const maturities = configs[chain.name].maturities ?? [];
 		for (const maturityName of maturities) rules.push({
 			type: "maturity",
 			chain_id: chain.id,
 			name: maturityName,
 			timestamp: from$16(maturityName)
 		});
-		const callbacks = config.callbacks ?? [];
-		for (const callback of callbacks) {
-			if (callback.type === Type$1.BuyWithEmptyCallback) continue;
-			if (!("addresses" in callback)) continue;
-			for (const address of callback.addresses) rules.push({
-				type: "callback",
-				chain_id: chain.id,
-				address: normalizeAddress(address),
-				callback_type: callback.type
-			});
-		}
 		const loanTokens = assets[chain.id.toString()] ?? [];
 		for (const address of loanTokens) rules.push({
 			type: "loan_token",
@@ -3177,6 +3164,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
@@ -3184,6 +3181,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: {
@@ -3210,15 +3209,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,
@@ -3367,8 +3366,8 @@ const offerExample = {
 		price: "2750000000000000000",
 		group: "0x000000000000000000000000000000000000000000000000000000000008b8f4",
 		session: "0x0000000000000000000000000000000000000000000000000000000000000000",
-		callback: "0x1111111111111111111111111111111111111111",
-		callback_data: "0x00000000000000000000000000000000000000000000000000000000000000400000000000000000000000000000000000000000000000000000000000000080000000000000000000000000000000000000000000000000000000000000000100000000000000000000000034cf890db685fc536e05652fb41f02090c3fb751000000000000000000000000000000000000000000000000000000000000000100000000000000000000000000108e644e3ab01184155270aa92a00000000000"
+		callback: "0x0000000000000000000000000000000000000000",
+		callback_data: "0x"
 	},
 	offer_hash: "0xac4bd8318ec914f89f8af913f162230575b0ac0696a19256bc12138c5cfe1427",
 	obligation_id: "0x25690ae1aee324a005be565f3bcdd16dbf8daf7969b26c181c8b8f467dad9abc",
@@ -3420,25 +3419,10 @@ const validateOfferExample = {
 		lltv: "860000000000000000"
 	}],
 	callback: {
-		address: "0x1111111111111111111111111111111111111111",
-		data: "0x00000000000000000000000000000000000000000000000000000000000000400000000000000000000000000000000000000000000000000000000000000080000000000000000000000000000000000000000000000000000000000000000100000000000000000000000034cf890db685fc536e05652fb41f02090c3fb751000000000000000000000000000000000000000000000000000000000000000100000000000000000000000000108e644e3ab01184155270aa92a00000000000"
+		address: "0x0000000000000000000000000000000000000000",
+		data: "0x"
 	}
 };
-const callbackTypesRequestExample = { callbacks: [{
-	chain_id: 1,
-	addresses: [
-		"0x1111111111111111111111111111111111111111",
-		"0x3333333333333333333333333333333333333333",
-		"0x9999999999999999999999999999999999999999"
-	]
-}] };
-const callbackTypesResponseExample = [{
-	chain_id: 1,
-	sell_erc20_callback: ["0x1111111111111111111111111111111111111111"],
-	buy_erc20: ["0x5555555555555555555555555555555555555555"],
-	buy_vault_v1_callback: ["0x3333333333333333333333333333333333333333"],
-	not_supported: ["0x9999999999999999999999999999999999999999"]
-}];
 const routerStatusExample = {
 	status: "live",
 	initialized: true,
@@ -3507,55 +3491,6 @@ __decorate([ApiProperty({
 	type: "string",
 	example: validateOfferExample.callback.data
 })], ValidateCallbackRequest.prototype, "data", void 0);
-var CallbackTypesChainRequest = class {};
-__decorate([ApiProperty({
-	type: "number",
-	example: callbackTypesRequestExample.callbacks[0].chain_id
-})], CallbackTypesChainRequest.prototype, "chain_id", void 0);
-__decorate([ApiProperty({
-	type: () => [String],
-	example: callbackTypesRequestExample.callbacks[0].addresses
-})], CallbackTypesChainRequest.prototype, "addresses", void 0);
-var CallbackTypesRequest = class {};
-__decorate([ApiProperty({
-	type: () => [CallbackTypesChainRequest],
-	example: callbackTypesRequestExample.callbacks
-})], CallbackTypesRequest.prototype, "callbacks", void 0);
-var CallbackTypesChainResponse = class {};
-__decorate([ApiProperty({
-	type: "number",
-	example: callbackTypesResponseExample[0].chain_id
-})], CallbackTypesChainResponse.prototype, "chain_id", void 0);
-__decorate([ApiProperty({
-	type: () => [String],
-	required: false,
-	example: callbackTypesResponseExample[0].buy_vault_v1_callback
-})], CallbackTypesChainResponse.prototype, "buy_vault_v1_callback", void 0);
-__decorate([ApiProperty({
-	type: () => [String],
-	required: false,
-	example: callbackTypesResponseExample[0].sell_erc20_callback
-})], CallbackTypesChainResponse.prototype, "sell_erc20_callback", void 0);
-__decorate([ApiProperty({
-	type: () => [String],
-	required: false,
-	example: callbackTypesResponseExample[0].buy_erc20
-})], CallbackTypesChainResponse.prototype, "buy_erc20", void 0);
-__decorate([ApiProperty({
-	type: () => [String],
-	example: callbackTypesResponseExample[0].not_supported
-})], CallbackTypesChainResponse.prototype, "not_supported", void 0);
-var CallbackTypesSuccessResponse = class extends SuccessResponse {};
-__decorate([ApiProperty({
-	type: "string",
-	nullable: true,
-	example: "maturity:1:1730415600:end_of_next_month"
-})], CallbackTypesSuccessResponse.prototype, "cursor", void 0);
-__decorate([ApiProperty({
-	type: () => [CallbackTypesChainResponse],
-	description: "Callback types grouped by chain.",
-	example: callbackTypesResponseExample
-})], CallbackTypesSuccessResponse.prototype, "data", void 0);
 var AskResponse = class {};
 __decorate([ApiProperty({
 	type: "string",
@@ -4073,7 +4008,7 @@ __decorate([
 		methods: ["post"],
 		path: "/v1/validate",
 		summary: "Validate offers",
-		description: "Validates offers against router validation rules. Returns unsigned payload + root on success, or issues only on validation failure."
+		description: "Validates offers against router validation rules. Only empty callbacks (zero address, 0x data) are accepted. Returns unsigned payload + root on success, or issues only on validation failure."
 	}),
 	ApiBody({ type: ValidateOffersRequest }),
 	ApiResponse({
@@ -4092,28 +4027,6 @@ ValidateController = __decorate([ApiTags("Make"), ApiResponse({
 	description: "Bad Request",
 	type: BadRequestResponse
 })], ValidateController);
-let CallbacksController = class CallbacksController {
-	async resolveCallbackTypes() {}
-};
-__decorate([
-	ApiOperation({
-		methods: ["post"],
-		path: "/v1/callbacks",
-		summary: "Resolve callback types",
-		description: "Returns callback types for callback addresses grouped by chain."
-	}),
-	ApiBody({ type: CallbackTypesRequest }),
-	ApiResponse({
-		status: 200,
-		description: "Success",
-		type: CallbackTypesSuccessResponse
-	})
-], CallbacksController.prototype, "resolveCallbackTypes", null);
-CallbacksController = __decorate([ApiTags("Make"), ApiResponse({
-	status: 400,
-	description: "Bad Request",
-	type: BadRequestResponse
-})], CallbacksController);
 let OffersController = class OffersController {
 	async getOffers() {}
 };
@@ -4263,12 +4176,6 @@ const configRulesMaturityExample = {
 	name: "end_of_next_month",
 	timestamp: 1730415600
 };
-const configRulesCallbackExample = {
-	type: "callback",
-	chain_id: 1,
-	address: "0x1111111111111111111111111111111111111111",
-	callback_type: "sell_erc20_callback"
-};
 const configRulesLoanTokenExample = {
 	type: "loan_token",
 	chain_id: 1,
@@ -4282,7 +4189,6 @@ const configRulesOracleExample = {
 const configRulesChecksumExample = "f1d2d2f924e986ac86fdf7b36c94bcdf";
 const configRulesPayloadExample = [
 	configRulesMaturityExample,
-	configRulesCallbackExample,
 	configRulesLoanTokenExample,
 	configRulesOracleExample
 ];
@@ -4347,14 +4253,9 @@ __decorate([ApiProperty({
 })], ConfigRulesRuleResponse.prototype, "timestamp", void 0);
 __decorate([ApiProperty({
 	type: "string",
-	example: configRulesCallbackExample.address,
+	example: configRulesLoanTokenExample.address,
 	required: false
 })], ConfigRulesRuleResponse.prototype, "address", void 0);
-__decorate([ApiProperty({
-	type: "string",
-	example: configRulesCallbackExample.callback_type,
-	required: false
-})], ConfigRulesRuleResponse.prototype, "callback_type", void 0);
 var ConfigRulesSuccessResponse = class {};
 __decorate([ApiProperty({ type: () => ConfigRulesMeta })], ConfigRulesSuccessResponse.prototype, "meta", void 0);
 __decorate([ApiProperty({
@@ -4415,7 +4316,7 @@ __decorate([
 		methods: ["get"],
 		path: "/v1/config/rules",
 		summary: "Get config rules",
-		description: "Returns configured rules for supported chains."
+		description: "Returns configured rules (maturities, loan tokens, oracles) for supported chains."
 	}),
 	ApiQuery({
 		name: "cursor",
@@ -4594,8 +4495,7 @@ const OpenApi = async () => {
 			ObligationsController,
 			HealthController,
 			UsersController,
-			ValidateController,
-			CallbacksController
+			ValidateController
 		],
 		document: {
 			openapi: "3.1.0",
@@ -4851,16 +4751,6 @@ const GetBookParams = z$2.object({
 	})
 });
 const ValidateOffersBody = z$2.object({ offers: z$2.array(z$2.unknown()).min(1, { message: "'offers' must contain at least 1 offer" }) }).strict();
-const CallbackTypesBody = z$2.object({ callbacks: z$2.array(z$2.object({
-	chain_id: z$2.number().int().positive().meta({
-		description: "Chain id.",
-		example: 1
-	}),
-	addresses: z$2.array(z$2.string().regex(/^0x[a-fA-F0-9]{40}$/, { error: "Callback address must be a valid 20-byte address" }).transform((val) => val.toLowerCase())).meta({
-		description: "Callback contract addresses.",
-		example: ["0x1111111111111111111111111111111111111111", "0x3333333333333333333333333333333333333333"]
-	})
-}).strict()) }).strict();
 const GetUserPositionsParams = z$2.object({
 	...PaginationQueryParams.shape,
 	user_address: z$2.string().regex(/^0x[a-fA-F0-9]{40}$/, { error: "User address must be a valid 20-byte address" }).transform((val) => val.toLowerCase()).meta({
@@ -4879,7 +4769,6 @@ const schemas = {
 	get_obligation: GetObligationParams,
 	get_book: GetBookParams,
 	validate_offers: ValidateOffersBody,
-	callback_types: CallbackTypesBody,
 	get_user_positions: GetUserPositionsParams
 };
 function safeParse(action, query, error) {
@@ -5135,35 +5024,6 @@ async function validateOffers(body, gatekeeper) {
 	}
 }
 
-//#endregion
-//#region src/gatekeeper/CallbackTypes.ts
-/**
-* Resolve callback types for a list of callback addresses grouped by chain.
-* @param parameters - Resolve parameters. {@link resolveCallbackTypes.Parameters}
-* @returns Callback types grouped by chain. {@link resolveCallbackTypes.ReturnType}
-* @throws If a chain id is unknown.
-*/
-function resolveCallbackTypes$2(parameters) {
-	const { chains, request } = parameters;
-	const chainsById = new Map(chains.map((chain) => [chain.id, chain]));
-	return request.callbacks.map(({ chain_id, addresses }) => {
-		const chain = chainsById.get(chain_id);
-		if (!chain) throw new Error(`Unknown chain id ${chain_id}`);
-		const buckets = /* @__PURE__ */ new Map();
-		const uniqueAddresses = new Set(addresses.map((address) => address.toLowerCase()));
-		for (const address of uniqueAddresses) {
-			const bucketKey = getCallbackType(chain.name, address) ?? "not_supported";
-			const list = buckets.get(bucketKey) ?? [];
-			list.push(address);
-			buckets.set(bucketKey, list);
-		}
-		const response = { chain_id };
-		for (const [type, list] of buckets.entries()) response[type] = list;
-		if (!response.not_supported) response.not_supported = [];
-		return response;
-	});
-}
-
 //#endregion
 //#region src/gatekeeper/Service.ts
 /**
@@ -5171,10 +5031,6 @@ function resolveCallbackTypes$2(parameters) {
 * @param parameters - App parameters including the {@link Gatekeeper} instance.
 * @returns Hono app exposing gatekeeper endpoints.
 */
-const CallbackTypesRequestSchema = z$2.object({ callbacks: z$2.array(z$2.object({
-	chain_id: z$2.number(),
-	addresses: z$2.array(z$2.string().regex(/^0x[a-fA-F0-9]{40}$/))
-})) });
 function createApp(parameters) {
 	const { gatekeeper, chainRegistry } = parameters;
 	const app = new Hono();
@@ -5183,12 +5039,12 @@ function createApp(parameters) {
 		try {
 			body = await c.req.json();
 		} catch (err) {
-			const failure$5 = failure(err);
-			return c.json(failure$5.body, failure$5.statusCode);
+			const failure$4 = failure(err);
+			return c.json(failure$4.body, failure$4.statusCode);
 		}
 		if (body === null || typeof body !== "object") {
-			const failure$9 = failure(new BadRequestError("Request body must be a JSON object"));
-			return c.json(failure$9.body, failure$9.statusCode);
+			const failure$3 = failure(new BadRequestError("Request body must be a JSON object"));
+			return c.json(failure$3.body, failure$3.statusCode);
 		}
 		const { statusCode, body: payload } = await validateOffers(body, gatekeeper);
 		return c.json(payload, statusCode);
@@ -5197,34 +5053,6 @@ function createApp(parameters) {
 		const { statusCode, body } = await getConfigRules(c.req.query(), chainRegistry.list());
 		return c.json(body, statusCode);
 	});
-	app.post("/v1/callbacks", async (c) => {
-		let body;
-		try {
-			body = await c.req.json();
-		} catch (err) {
-			const failure$8 = failure(err);
-			return c.json(failure$8.body, failure$8.statusCode);
-		}
-		if (body === null || typeof body !== "object") {
-			const failure$6 = failure(new BadRequestError("Request body must be a JSON object"));
-			return c.json(failure$6.body, failure$6.statusCode);
-		}
-		try {
-			const request = CallbackTypesRequestSchema.parse(body);
-			const chainIds = new Set(chainRegistry.list().map((chain) => chain.id));
-			const unknown = request.callbacks.find((entry) => !chainIds.has(entry.chain_id));
-			if (unknown) throw new BadRequestError(`Unknown chain id ${unknown.chain_id}`);
-			const data = resolveCallbackTypes$2({
-				chains: chainRegistry.list(),
-				request
-			});
-			const response = success({ data });
-			return c.json(response.body, response.statusCode);
-		} catch (err) {
-			const failure$7 = failure(err);
-			return c.json(failure$7.body, failure$7.statusCode);
-		}
-	});
 	return app;
 }
 /**
@@ -5320,1559 +5148,8 @@ function now() {
 }
 
 //#endregion
-//#region src/indexer/collectors/CollectFunctions/collectConsumedEvents.ts
-async function* collectConsumedEvents(parameters) {
-	let { db, collector, client, lastBlockNumber: blockNumber, epoch, options: { maxBatchSize = 1e3, blockWindow } = {} } = parameters;
-	const logger = getLogger();
-	let startBlock = blockNumber;
-	let reorgDetected = false;
-	const { blockNumber: latestBlockNumberChain } = await db.blocks.getChain(client.chain.id);
-	const stream = streamLogs({
-		client,
-		contractAddress: client.chain.custom.morpho.address,
-		event: consumedEvent,
-		blockNumberGte: blockNumber,
-		blockNumberLte: latestBlockNumberChain,
-		order: "asc",
-		options: {
-			maxBatchSize,
-			blockWindow
-		}
-	});
-	for await (const { logs, blockNumber: lastStreamBlockNumber } of stream) {
-		const parsedLogs = parseEventLogs({
-			abi: [consumedEvent],
-			logs
-		});
-		const events = [];
-		for (const log of parsedLogs) {
-			if (log.blockNumber === null || log.logIndex === null || log.transactionHash === null) {
-				logger.debug({
-					collector,
-					chainId: client.chain.id,
-					msg: "Skipping log because it is missing required fields"
-				});
-				continue;
-			}
-			events.push({
-				id: `${log.blockNumber.toString()}-${log.logIndex.toString()}-${client.chain.id}-${log.transactionHash}`,
-				chainId: client.chain.id,
-				maker: log.args.user,
-				group: log.args.group,
-				amount: log.args.amount,
-				blockNumber: Number(log.blockNumber)
-			});
-		}
-		await db.transaction(async (dbTx) => {
-			try {
-				await dbTx.consumed.create(events);
-				if (events.length > 0) logger.info({
-					msg: `Events indexed`,
-					collector,
-					count: events.length,
-					chain_id: client.chain.id,
-					block_range: [startBlock, lastStreamBlockNumber]
-				});
-			} catch (err) {
-				logger.error({
-					err,
-					msg: "Failed to process offer_consumed events"
-				});
-			}
-			blockNumber = lastStreamBlockNumber;
-			try {
-				await dbTx.blocks.advanceCollector({
-					collectorName: collector,
-					chainId: client.chain.id,
-					blockNumber,
-					epoch
-				});
-			} catch (_) {
-				try {
-					const ancestor = await dbTx.blocks.getCollector({
-						collectorName: collector,
-						chainId: client.chain.id
-					});
-					blockNumber = ancestor.blockNumber;
-					const deleted = await dbTx.consumed.delete({
-						chainId: client.chain.id,
-						blockNumberGte: blockNumber + 1
-					});
-					logger.info({
-						collector,
-						chain_id: client.chain.id,
-						msg: `Reorg detected, events deleted`,
-						count: deleted,
-						block_number: blockNumber
-					});
-					await dbTx.blocks.advanceCollector({
-						collectorName: collector,
-						chainId: client.chain.id,
-						blockNumber,
-						epoch: ancestor.epoch
-					});
-					reorgDetected = true;
-				} catch (err) {
-					const msg = "Failed to delete consumed events when handling reorg.";
-					logger.error({
-						collector,
-						chainId: client.chain.id,
-						msg,
-						err
-					});
-					throw new Error(msg);
-				}
-			}
-		});
-		if (reorgDetected) return;
-		yield blockNumber;
-		startBlock = blockNumber;
-	}
-}
-
-//#endregion
-//#region src/indexer/collectors/CollectFunctions/collectOffers.ts
-async function* collectOffersV2(parameters) {
-	let { db, collector, client, lastBlockNumber: blockNumber, gatekeeper, options: { maxBatchSize = 1e3, blockWindow } = {} } = parameters;
-	const logger = getLogger();
-	let startBlock = blockNumber;
-	let reorgDetected = false;
-	if (client.chain.custom.morpho.address.toLowerCase() === zeroAddress) {
-		const msg = "Morpho V2 address is zero, signature verification will fail. Please set the Morpho V2 address in the chain configuration.";
-		logger.error({
-			msg,
-			chain_id: client.chain.id
-		});
-		throw new Error(msg);
-	}
-	const signatureDomain = {
-		chainId: client.chain.id,
-		verifyingContract: client.chain.custom.morpho.address
-	};
-	const { blockNumber: latestBlockNumberChain } = await db.blocks.getChain(client.chain.id);
-	const stream = streamLogs({
-		client,
-		contractAddress: client.chain.custom.mempool.address,
-		event: {
-			type: "event",
-			name: "Event",
-			inputs: [{
-				name: "data",
-				type: "bytes",
-				indexed: false,
-				internalType: "bytes"
-			}],
-			anonymous: false
-		},
-		blockNumberGte: blockNumber,
-		blockNumberLte: latestBlockNumberChain,
-		order: "asc",
-		options: {
-			maxBatchSize,
-			blockWindow
-		}
-	});
-	for await (const { logs, blockNumber: lastStreamBlockNumber } of stream) {
-		blockNumber = lastStreamBlockNumber;
-		const decodedTrees = [];
-		for (const log of logs) {
-			if (!log) continue;
-			const [payload] = decodeAbiParameters([{ type: "bytes" }], log.data);
-			try {
-				const { tree, signature, signer } = await decode(payload, signatureDomain);
-				const signerMismatch = tree.offers.find((offer) => offer.maker.toLowerCase() !== signer.toLowerCase());
-				if (signerMismatch) {
-					logger.debug({
-						msg: "Tree rejected: signer mismatch",
-						reason: "signer_mismatch",
-						signer,
-						maker: signerMismatch.maker,
-						chain_id: client.chain.id
-					});
-					continue;
-				}
-				decodedTrees.push({
-					tree,
-					signature,
-					signer,
-					blockNumber: Number(log.blockNumber)
-				});
-			} catch (err) {
-				const reason = err instanceof DecodeError && err.message.includes("signature") ? "invalid_signature" : "decode_failed";
-				logger.debug({
-					msg: "Tree decode failed",
-					reason,
-					chain_id: client.chain.id,
-					err: err instanceof Error ? err.message : String(err)
-				});
-			}
-		}
-		await db.transaction(async (dbTx) => {
-			const { epoch, blockNumber: latestBlockNumber } = await dbTx.blocks.getChain(client.chain.id);
-			const treesToInsert = [];
-			let totalValidOffers = 0;
-			const offersWithBlock = [];
-			for (const { tree, signature, blockNumber: treeBlockNumber } of decodedTrees) try {
-				const allowedResults = await gatekeeper.isAllowed(tree.offers);
-				const hasBlockWindowViolation = treeBlockNumber > latestBlockNumber;
-				if (!(allowedResults.issues.length === 0 && allowedResults.valid.length === tree.offers.length) || hasBlockWindowViolation) {
-					if (allowedResults.issues.length > 0) {
-						const hasMixedMaker = allowedResults.issues.some((i) => i.ruleName === "mixed_maker");
-						logger.debug({
-							msg: "Tree offers rejected by gatekeeper",
-							reason: hasMixedMaker ? "mixed_maker" : "gatekeeper_rejected",
-							chain_id: client.chain.id,
-							issues_count: allowedResults.issues.length
-						});
-					} else if (hasBlockWindowViolation) logger.debug({
-						msg: "Tree rejected: offers outside block window",
-						reason: "block_window",
-						chain_id: client.chain.id
-					});
-					continue;
-				}
-				treesToInsert.push({
-					tree,
-					signature
-				});
-				totalValidOffers += tree.offers.length;
-				offersWithBlock.push(...tree.offers.map((offer) => ({
-					offer,
-					blockNumber: treeBlockNumber
-				})));
-			} catch (err) {
-				const error = err instanceof Error ? err : new Error(String(err));
-				logger.error({
-					err: error,
-					msg: "Gatekeeper validation failed",
-					chain_id: client.chain.id
-				});
-				throw new Error("Gatekeeper validation failed", { cause: error });
-			}
-			const dependencies = buildOfferDependencies$1(offersWithBlock);
-			await dbTx.oracles.upsert(dependencies.oracles);
-			await dbTx.obligations.create(dependencies.obligations);
-			await dbTx.groups.create(dependencies.groups);
-			const insertedHashes = await dbTx.offers.create(dependencies.offerBatches);
-			if (treesToInsert.length > 0) await dbTx.trees.create(treesToInsert);
-			const insertedOffers = filterInsertedOffers({
-				offers: offersWithBlock,
-				hashes: insertedHashes
-			});
-			const { callbacks, positions, lots } = await decodeCallbacks({
-				chainId: client.chain.id,
-				gatekeeper,
-				offers: insertedOffers
-			});
-			if (positions.length > 0) await dbTx.positions.upsert(positions);
-			if (callbacks.length > 0) await dbTx.callbacks.upsert(callbacks);
-			if (lots.length > 0) await dbTx.lots.create(lots);
-			try {
-				await dbTx.blocks.advanceCollector({
-					collectorName: collector,
-					chainId: client.chain.id,
-					blockNumber,
-					epoch
-				});
-				if (totalValidOffers > 0) logger.info({
-					msg: `New offers`,
-					collector,
-					count: totalValidOffers,
-					trees_count: treesToInsert.length,
-					chain_id: client.chain.id,
-					block_range: [startBlock, lastStreamBlockNumber]
-				});
-			} catch (_) {
-				try {
-					const ancestor = await dbTx.blocks.getCollector({
-						collectorName: collector,
-						chainId: client.chain.id
-					});
-					blockNumber = ancestor.blockNumber;
-					const deleted = await dbTx.offers.delete({
-						blockNumberGte: blockNumber + 1,
-						chainId: client.chain.id
-					});
-					logger.info({
-						collector,
-						chain_id: client.chain.id,
-						msg: `Reorg detected, offers deleted`,
-						count: deleted,
-						block_number: blockNumber
-					});
-					await dbTx.blocks.advanceCollector({
-						collectorName: collector,
-						chainId: client.chain.id,
-						blockNumber,
-						epoch: ancestor.epoch
-					});
-					reorgDetected = true;
-				} catch (err) {
-					const msg = "Failed to delete offers when handling reorg.";
-					logger.error({
-						collector,
-						chainId: client.chain.id,
-						msg,
-						err
-					});
-					throw new Error(msg);
-				}
-			}
-		});
-		if (reorgDetected) return;
-		yield blockNumber;
-		startBlock = blockNumber;
-	}
-}
-async function decodeCallbacks(parameters) {
-	const { chainId, gatekeeper, offers } = parameters;
-	if (offers.length === 0) return {
-		callbacks: [],
-		positions: [],
-		lots: []
-	};
-	const addresses = offers.filter((entry) => entry.offer.callback.data !== "0x").map((entry) => entry.offer.callback.address);
-	if (addresses.length === 0) return {
-		callbacks: [],
-		positions: [],
-		lots: []
-	};
-	let response;
-	try {
-		response = await gatekeeper.getCallbackTypes({ callbacks: [{
-			chain_id: chainId,
-			addresses
-		}] });
-	} catch (err) {
-		const error = err instanceof Error ? err : new Error(String(err));
-		throw new Error("Failed to resolve callback types", { cause: error });
-	}
-	const entry = response.find((item) => item.chain_id === chainId);
-	const typeByAddress = /* @__PURE__ */ new Map();
-	if (entry) for (const [key, list] of Object.entries(entry)) {
-		if (key === "chain_id" || key === "not_supported") continue;
-		if (!Array.isArray(list)) continue;
-		for (const address of list) typeByAddress.set(address.toLowerCase(), key);
-	}
-	const callbacks = [];
-	const positions = [];
-	const lots = [];
-	for (const { offer, blockNumber: offerBlockNumber } of offers) {
-		if (offer.callback.data === "0x") continue;
-		const callbackType = typeByAddress.get(offer.callback.address.toLowerCase());
-		if (!callbackType) continue;
-		let decoded;
-		try {
-			decoded = decode$1(callbackType, offer.callback.data);
-		} catch (err) {
-			const error = err instanceof Error ? err : new Error(String(err));
-			throw new Error("Failed to decode callback data", { cause: error });
-		}
-		if (decoded.length === 0) continue;
-		const offerHash = hash(offer);
-		const callbackInputs = decoded.map((callback) => ({
-			chainId: offer.chainId,
-			contract: callback.contract,
-			user: offer.maker,
-			amount: callback.amount
-		}));
-		callbacks.push({
-			offerHash,
-			callbacks: callbackInputs
-		});
-		for (const callback of decoded) {
-			const contract = callback.contract;
-			const positionType = callbackType === Type$1.BuyVaultV1Callback ? Type.VAULT_V1 : Type.ERC20;
-			const asset = callbackType === Type$1.BuyVaultV1Callback ? void 0 : contract;
-			positions.push(from$10({
-				chainId: offer.chainId,
-				contract,
-				user: offer.maker,
-				type: positionType,
-				asset,
-				blockNumber: offerBlockNumber
-			}));
-			const isLoanPosition = offer.loanToken.toLowerCase() === asset?.toLowerCase();
-			lots.push({
-				positionChainId: offer.chainId,
-				positionContract: contract,
-				positionUser: offer.maker,
-				group: offer.group,
-				size: isLoanPosition ? offer.assets : callback.amount
-			});
-		}
-	}
-	return {
-		callbacks,
-		positions,
-		lots
-	};
-}
-function buildOfferDependencies$1(offers) {
-	const obligationsById = /* @__PURE__ */ new Map();
-	const oraclesByKey = /* @__PURE__ */ new Map();
-	const groupsByKey = /* @__PURE__ */ new Map();
-	const offersByBlock = /* @__PURE__ */ new Map();
-	for (const { offer, blockNumber } of offers) {
-		const list = offersByBlock.get(blockNumber) ?? [];
-		list.push(offer);
-		offersByBlock.set(blockNumber, list);
-		const obligationId$2 = obligationId(offer);
-		if (!obligationsById.get(obligationId$2)) obligationsById.set(obligationId$2, from$13({
-			chainId: offer.chainId,
-			loanToken: offer.loanToken,
-			maturity: offer.maturity,
-			collaterals: offer.collaterals
-		}));
-		for (const collateral of offer.collaterals) {
-			const oracleKey = `${offer.chainId}-${collateral.oracle}`.toLowerCase();
-			if (!oraclesByKey.has(oracleKey)) oraclesByKey.set(oracleKey, from$11({
-				chainId: offer.chainId,
-				address: collateral.oracle,
-				price: null,
-				blockNumber
-			}));
-		}
-		const groupKey = `${offer.chainId}-${offer.maker}-${offer.group}`.toLowerCase();
-		if (!groupsByKey.has(groupKey)) groupsByKey.set(groupKey, {
-			chainId: offer.chainId,
-			maker: offer.maker,
-			group: offer.group,
-			blockNumber
-		});
-	}
-	return {
-		obligations: Array.from(obligationsById.values()),
-		oracles: Array.from(oraclesByKey.values()),
-		groups: Array.from(groupsByKey.values()),
-		offerBatches: Array.from(offersByBlock.entries()).map(([blockNumber, items]) => ({
-			blockNumber,
-			offers: items
-		}))
-	};
-}
-function filterInsertedOffers(parameters) {
-	if (parameters.hashes.length === 0) return [];
-	const inserted = new Set(parameters.hashes.map((hash) => hash.toLowerCase()));
-	const seen = /* @__PURE__ */ new Set();
-	const filtered = [];
-	for (const entry of parameters.offers) {
-		const hash$2 = hash(entry.offer).toLowerCase();
-		if (!inserted.has(hash$2)) continue;
-		if (seen.has(hash$2)) continue;
-		seen.add(hash$2);
-		filtered.push(entry);
-	}
-	return filtered;
-}
-
-//#endregion
-//#region src/indexer/collectors/fetchers/fetchOraclePrices.ts
-/**
-* Fetches prices from multiple oracle contracts using multicall.
-*
-* - Executes `price()` on {@link Abi.Oracle} for each {@link Address}.
-* - Requires a client supporting {@link PublicActions.multicall | multicall}.
-*
-* @param parameters - {@link fetchOraclePrices.Parameters} including the list of oracle
-* {@link Address | addresses}, fetch options, and the multicall-enabled client.
-* @returns {@link fetchOraclePrices.ReturnType} mapping {@link Address} to `bigint` price.
-*/
-async function fetchOraclePrices(parameters) {
-	const { client, oracles, options } = parameters;
-	if (oracles.length === 0) return /* @__PURE__ */ new Map();
-	const batchSize = Math.max(1, options?.batchSize ?? 5e3);
-	const retryAttempts = Math.max(1, options?.retryAttempts ?? 3);
-	const retryDelayMs = Math.max(0, options?.retryDelayMs ?? 50);
-	const blockNumber = options?.blockNumber ? BigInt(options.blockNumber) : void 0;
-	const out = /* @__PURE__ */ new Map();
-	for (const oraclesBatch of batch$1(oracles, batchSize)) {
-		const priceCalls = [];
-		for (const oracle of oraclesBatch) priceCalls.push({
-			address: oracle,
-			abi: Oracle,
-			functionName: "price",
-			args: []
-		});
-		const prices = await batchMulticall({
-			client,
-			calls: priceCalls,
-			batchSize,
-			retryAttempts,
-			retryDelayMs,
-			blockNumber
-		});
-		for (let i = 0; i < oraclesBatch.length; i++) {
-			const oracle = oraclesBatch[i];
-			const price = prices[i];
-			out.set(oracle, price);
-		}
-	}
-	return out;
-}
-
-//#endregion
-//#region src/indexer/collectors/fetchers/snapshotERC20Positions.ts
-/**
-* Fetches ERC20 balances for positions at a given block number and returns the positions with the updated balances.
-* @notice This method does not mutate positions and returns a new array.
-*
-* @param parameters - {@link snapshotERC20Positions.Parameters}
-* @returns Positions - {@link snapshotERC20Positions.ReturnType}
-*/
-async function snapshotERC20Positions(parameters) {
-	const { positions: oldPositions, blockNumber, options: { maxBatchSize = 1e3, retryAttempts = 5, retryDelayMs = 500 } = {} } = parameters;
-	if (oldPositions.length === 0) return [];
-	const calls = [];
-	for (const position of oldPositions) calls.push({
-		address: position.contract,
-		abi: erc20Abi,
-		functionName: "balanceOf",
-		args: [position.user]
-	});
-	const balances = await batchMulticall({
-		client: parameters.client,
-		calls,
-		blockNumber: BigInt(blockNumber),
-		batchSize: maxBatchSize,
-		retryAttempts,
-		retryDelayMs
-	});
-	const positions = [];
-	for (let i = 0; i < balances.length; i++) {
-		const oldPosition = oldPositions[i];
-		if (!oldPosition) continue;
-		positions.push({
-			...oldPosition,
-			balance: balances[i],
-			blockNumber
-		});
-	}
-	return positions;
-}
-
-//#endregion
-//#region src/indexer/collectors/fetchers/snapshotVaultPositions.ts
-/**
-* Fetches vault shares for users at a given block number, converts them to assets and returns the positions with the updated balances.
-* @notice This method does not mutate positions and returns a new array.
-*
-* @param parameters - {@link snapshotVaultPositions.Parameters}
-* @returns Positions - {@link snapshotVaultPositions.ReturnType}
-*/
-async function snapshotVaultPositions(parameters) {
-	const logger = getLogger();
-	const { client, positions: oldPositions, blockNumber, options: { maxBatchSize = 1e3, retryAttempts = 5, retryDelayMs = 500 } = {} } = parameters;
-	const calls = [];
-	const contracts = /* @__PURE__ */ new Map();
-	const positions = structuredClone(oldPositions);
-	for (const position of positions) {
-		calls.push({
-			address: position.contract,
-			abi: MetaMorpho,
-			functionName: "balanceOf",
-			args: [position.user],
-			convertToAssets: (shares) => {
-				const contract = contracts.get(position.contract.toLowerCase());
-				if (!contract) return;
-				if (contract.decimalsOffset === void 0 || contract.totalAssets === void 0 || contract.totalSupply === void 0) return;
-				try {
-					position.balance = convertToAssets({
-						shares,
-						totalAssets: contract.totalAssets,
-						totalSupply: contract.totalSupply,
-						decimalsOffset: contract.decimalsOffset
-					});
-					position.asset = contract.asset;
-					position.blockNumber = blockNumber;
-				} catch (err) {
-					if (err instanceof DenominatorIsZeroError) {
-						logger.error({
-							msg: "Failed to convert shares to assets",
-							chain_id: client.chain.id,
-							block_number: blockNumber,
-							position_contract: position.contract,
-							position_user: position.user,
-							shares,
-							err
-						});
-						return;
-					}
-					throw err;
-				}
-			}
-		});
-		if (contracts.has(position.contract.toLowerCase())) continue;
-		calls.push({
-			address: position.contract,
-			abi: MetaMorpho,
-			functionName: "DECIMALS_OFFSET",
-			args: []
-		}, {
-			address: position.contract,
-			abi: MetaMorpho,
-			functionName: "totalAssets",
-			args: []
-		}, {
-			address: position.contract,
-			abi: MetaMorpho,
-			functionName: "totalSupply",
-			args: []
-		}, {
-			address: position.contract,
-			abi: MetaMorpho,
-			functionName: "asset",
-			args: []
-		});
-		contracts.set(position.contract.toLowerCase(), {
-			decimalsOffset: void 0,
-			totalAssets: void 0,
-			totalSupply: void 0,
-			asset: void 0
-		});
-	}
-	const results = await batchMulticall({
-		client,
-		calls,
-		blockNumber: BigInt(blockNumber),
-		batchSize: maxBatchSize,
-		retryAttempts,
-		retryDelayMs
-	});
-	const convertToAssetsList = [];
-	for (let i = 0; i < results.length; i++) {
-		const call = calls[i];
-		const value = results[i];
-		const contract = contracts.get(call.address.toLowerCase());
-		if (!contract) continue;
-		switch (call.functionName) {
-			case "balanceOf":
-				convertToAssetsList.push(() => call.convertToAssets(value));
-				break;
-			case "DECIMALS_OFFSET":
-				contract.decimalsOffset = value;
-				break;
-			case "totalAssets":
-				contract.totalAssets = value;
-				break;
-			case "totalSupply":
-				contract.totalSupply = value;
-				break;
-			case "asset":
-				contract.asset = value.toLowerCase();
-				break;
-		}
-	}
-	for (const convertToAssets of convertToAssetsList) convertToAssets();
-	return positions;
-}
-
-//#endregion
-//#region src/indexer/collectors/CollectFunctions/collectPositions.ts
-async function* collectPositions(parameters) {
-	let { db, collector, client, lastBlockNumber: blockNumber, epoch, options: { maxBatchSize = 1e3, retryAttempts = 5, retryDelayMs = 500, blockWindow } = {} } = parameters;
-	const logger = getLogger();
-	let startBlock = blockNumber;
-	let reorgDetected = false;
-	const TransferEvent = {
-		type: "event",
-		name: "Transfer",
-		inputs: [
-			{
-				name: "from",
-				type: "address",
-				indexed: true
-			},
-			{
-				name: "to",
-				type: "address",
-				indexed: true
-			},
-			{
-				name: "value",
-				type: "uint256",
-				indexed: false
-			}
-		]
-	};
-	const { blockNumber: latestBlockNumberChain } = await db.blocks.getChain(client.chain.id);
-	const stream = streamLogs({
-		client,
-		event: TransferEvent,
-		blockNumberGte: blockNumber,
-		blockNumberLte: latestBlockNumberChain,
-		order: "asc",
-		options: {
-			maxBatchSize,
-			blockWindow
-		}
-	});
-	for await (const { logs, blockNumber: lastStreamBlockNumber } of stream) {
-		blockNumber = lastStreamBlockNumber;
-		const parsedLogs = parseEventLogs({
-			abi: [TransferEvent],
-			logs
-		});
-		const transfers = [];
-		for (const log of parsedLogs) {
-			if (log.blockNumber === null || log.logIndex === null || log.transactionHash === null) {
-				logger.debug({
-					collector,
-					chainId: client.chain.id,
-					msg: "Skipping log because it is missing required fields"
-				});
-				continue;
-			}
-			transfers.push(from$8({
-				id: `${client.chain.id}-${log.blockNumber.toString()}-${log.transactionHash}-${log.logIndex.toString()}`,
-				chainId: client.chain.id,
-				contract: log.address,
-				from: log.args.from,
-				to: log.args.to,
-				value: log.args.value,
-				blockNumber: Number(log.blockNumber)
-			}));
-		}
-		const { positions } = await db.positions.get({
-			chainId: client.chain.id,
-			filled: false
-		});
-		const newPositions = [];
-		try {
-			newPositions.push(...(await _snapshot({
-				positions,
-				blockNumber: latestBlockNumberChain,
-				client,
-				maxBatchSize,
-				retryAttempts,
-				retryDelayMs
-			})).map((p) => ({
-				...p,
-				blockNumber: p.blockNumber + 1
-			})));
-		} catch (err) {
-			logger.error({
-				msg: "Failed to snapshot new empty positions",
-				collector,
-				chain_id: client.chain.id,
-				block_number: latestBlockNumberChain,
-				err
-			});
-			yield startBlock;
-			return;
-		}
-		try {
-			await db.transaction(async (dbTx) => {
-				const insertPositions = async () => {
-					if (newPositions.length === 0) return;
-					try {
-						const count = await dbTx.positions.upsert(newPositions);
-						logger.info({
-							msg: `New positions`,
-							collector,
-							count,
-							chain_id: client.chain.id,
-							block_number: latestBlockNumberChain
-						});
-					} catch (err) {
-						throw new InsertPositionsError(err);
-					}
-				};
-				const insertTransfers = async () => {
-					if (transfers.length === 0) return;
-					try {
-						const created = await dbTx.transfers.create(transfers);
-						logger.info({
-							msg: `New transfers`,
-							collector,
-							count: created,
-							chain_id: client.chain.id,
-							block_range: [startBlock, blockNumber]
-						});
-					} catch (err) {
-						throw new InsertTransfersError(err);
-					}
-				};
-				const saveBlockNumber = async () => {
-					try {
-						await dbTx.blocks.advanceCollector({
-							collectorName: collector,
-							chainId: client.chain.id,
-							blockNumber,
-							epoch
-						});
-					} catch (_) {
-						throw new ReorgError(blockNumber);
-					}
-				};
-				await insertPositions();
-				await insertTransfers();
-				await saveBlockNumber();
-			});
-		} catch (err) {
-			if (err instanceof ReorgError) {
-				logger.info({
-					msg: "Reorg detected, positions and transfers insertion aborted",
-					collector,
-					count: newPositions.length,
-					chain_id: client.chain.id,
-					block_number: blockNumber
-				});
-				reorgDetected = true;
-			}
-			if (err instanceof InsertPositionsError) {
-				logger.error({
-					msg: "Failed to insert positions",
-					collector,
-					count: newPositions.length,
-					chain_id: client.chain.id,
-					block_number: latestBlockNumberChain,
-					err
-				});
-				throw err.cause;
-			}
-			if (err instanceof InsertTransfersError) {
-				logger.error({
-					msg: "Failed to insert transfers",
-					collector,
-					count: transfers.length,
-					chain_id: client.chain.id,
-					block_number: blockNumber,
-					err
-				});
-				throw err.cause;
-			}
-		}
-		if (!reorgDetected) {
-			startBlock = blockNumber;
-			if (newPositions.length === 0 && transfers.length === 0 && lastStreamBlockNumber !== latestBlockNumberChain) continue;
-			yield blockNumber;
-			continue;
-		}
-		await db.transaction(async (dbTx) => {
-			try {
-				const ancestor = await dbTx.blocks.getCollector({
-					collectorName: collector,
-					chainId: client.chain.id
-				});
-				blockNumber = ancestor.blockNumber;
-				const emptied = await dbTx.positions.setEmptyAfter({
-					chainId: client.chain.id,
-					blockNumber: blockNumber + 1
-				});
-				logger.info({
-					msg: "Reorg detected, positions set to empty",
-					collector,
-					count: emptied,
-					chain_id: client.chain.id,
-					block_number_gte: blockNumber + 1
-				});
-				await dbTx.blocks.advanceCollector({
-					collectorName: collector,
-					chainId: client.chain.id,
-					blockNumber,
-					epoch: ancestor.epoch
-				});
-			} catch (err) {
-				const msg = "Failed to revert to ancestor block when handling reorg.";
-				logger.error({
-					collector,
-					chainId: client.chain.id,
-					msg,
-					err
-				});
-				throw new Error(msg);
-			}
-		});
-		return;
-	}
-}
-/**
-* @internal
-*
-* Snapshots positions and returns the new positions.
-* @param parameters - {@link _snapshot.Parameters}
-* @returns The new positions. {@link _snapshot.ReturnType}
-*/
-async function _snapshot(parameters) {
-	const { positions, blockNumber, client, maxBatchSize, retryAttempts, retryDelayMs } = parameters;
-	const vaultV1Positions = [];
-	const erc20Positions = [];
-	for (const position of positions) switch (position.type) {
-		case Type.VAULT_V1:
-			vaultV1Positions.push(position);
-			break;
-		case Type.ERC20:
-			erc20Positions.push(position);
-			break;
-		default: throw new Error("Invalid position type");
-	}
-	const promises = [snapshotVaultPositions({
-		client,
-		positions: vaultV1Positions,
-		blockNumber,
-		options: {
-			maxBatchSize,
-			retryAttempts,
-			retryDelayMs
-		}
-	}), snapshotERC20Positions({
-		client,
-		positions: erc20Positions,
-		blockNumber,
-		options: {
-			maxBatchSize,
-			retryAttempts,
-			retryDelayMs
-		}
-	})];
-	return (await Promise.all(promises)).flat();
-}
-var InsertPositionsError = class extends BaseError {
-	name = "InsertPositionsError";
-	constructor(err) {
-		super("Failed to insert positions", { cause: err });
-	}
-};
-var InsertTransfersError = class extends BaseError {
-	name = "InsertTransfersError";
-	constructor(err) {
-		super("Failed to insert transfers", { cause: err });
-	}
-};
-
-//#endregion
-//#region src/indexer/collectors/CollectFunctions/collectPrices.ts
-/**
-* Collects oracle prices from on-chain oracles and persists them.
-*
-* - Reads oracle definitions as {@link Oracle.Oracle}.
-* - Uses chain metadata from {@link Chain.Chain}.
-*
-* @param parameters - {@link collectPrices.Parameters} (extends {@link Collector.CollectParameters})
-* with a client supporting {@link PublicActions.multicall | multicall}.
-* @yields Latest processed block number after each successful update.
-*/
-async function* collectPrices(parameters) {
-	const { db, collector, client, options: { maxBatchSize = 5e3, retryAttempts = 5, retryDelayMs = 500 } = {} } = parameters;
-	const logger = getLogger();
-	let blockNumber = parameters.lastBlockNumber;
-	const [oracles, { blockNumber: latestBlockNumberChain, epoch }] = await Promise.all([db.oracles.get({ chainId: client.chain.id }), db.blocks.getChain(client.chain.id)]);
-	const updatedOracles = [];
-	try {
-		const pricesMap = await fetchOraclePrices({
-			client,
-			oracles: oracles.map((oracle) => oracle.address),
-			options: {
-				batchSize: maxBatchSize,
-				blockNumber: latestBlockNumberChain,
-				retryAttempts,
-				retryDelayMs
-			}
-		});
-		for (const oracle of oracles) {
-			const price = pricesMap.get(oracle.address);
-			if (price !== void 0) updatedOracles.push({
-				chainId: client.chain.id,
-				address: oracle.address,
-				price,
-				blockNumber: latestBlockNumberChain
-			});
-		}
-	} catch (err) {
-		logger.error({
-			msg: "Failed to fetch oracle prices",
-			collector,
-			chain_id: client.chain.id,
-			block_number: latestBlockNumberChain,
-			err
-		});
-		yield blockNumber;
-		return;
-	}
-	let reorgDetected = false;
-	try {
-		await db.transaction(async (dbTx) => {
-			if (updatedOracles.length > 0) {
-				await dbTx.oracles.upsert(updatedOracles);
-				logger.info({
-					msg: "Oracle prices updated",
-					collector,
-					count: updatedOracles.length,
-					chain_id: client.chain.id,
-					block_number: latestBlockNumberChain
-				});
-			}
-			try {
-				await dbTx.blocks.advanceCollector({
-					collectorName: collector,
-					chainId: client.chain.id,
-					blockNumber: latestBlockNumberChain,
-					epoch
-				});
-			} catch (_) {
-				throw new ReorgError(latestBlockNumberChain);
-			}
-			blockNumber = latestBlockNumberChain;
-		});
-	} catch (err) {
-		if (err instanceof ReorgError) {
-			logger.info({
-				msg: "Reorg detected, prices update aborted",
-				collector,
-				count: updatedOracles.length,
-				chain_id: client.chain.id,
-				block_number: latestBlockNumberChain
-			});
-			reorgDetected = true;
-		} else throw new Error("Failed to collect oracle prices", { cause: err });
-	}
-	if (!reorgDetected) {
-		yield blockNumber;
-		return;
-	}
-	await db.transaction(async (dbTx) => {
-		try {
-			const ancestor = await dbTx.blocks.getCollector({
-				collectorName: collector,
-				chainId: client.chain.id
-			});
-			blockNumber = ancestor.blockNumber;
-			await dbTx.blocks.advanceCollector({
-				collectorName: collector,
-				chainId: client.chain.id,
-				blockNumber,
-				epoch: ancestor.epoch
-			});
-		} catch (err) {
-			const msg = "Failed to revert to ancestor block when handling reorg.";
-			logger.error({
-				collector,
-				chainId: client.chain.id,
-				msg,
-				err
-			});
-			throw new Error(msg);
-		}
-	});
-	yield blockNumber;
-}
-
-//#endregion
-//#region src/indexer/collectors/CollectorBuilder.ts
-function createBuilder(parameters) {
-	const { client, db, gatekeeper, options: { maxBlockNumber, blockWindow, interval } = {} } = parameters;
-	const createCollector = (name, collect) => create$16({
-		name,
-		collect,
-		client,
-		db,
-		options: {
-			maxBlockNumber,
-			interval
-		}
-	});
-	return {
-		buildOffersCollector: ({ options: { maxBatchSize = 1e3 } = {} }) => {
-			return createCollector("offers", (p) => collectOffersV2({
-				...p,
-				gatekeeper,
-				collector: "offers",
-				client,
-				options: {
-					maxBatchSize,
-					blockWindow
-				}
-			}));
-		},
-		buildConsumedEventsCollector: ({ options: { maxBatchSize = 1e3 } = {} } = {}) => {
-			return createCollector("consumed_events", (p) => collectConsumedEvents({
-				...p,
-				collector: "consumed_events",
-				options: {
-					maxBatchSize,
-					blockWindow
-				}
-			}));
-		},
-		buildPricesCollector: ({ options: { maxBatchSize = 5e3, retryAttempts, retryDelayMs } = {} } = {}) => {
-			return createCollector("prices", (p) => collectPrices({
-				...p,
-				collector: "prices",
-				options: {
-					maxBatchSize,
-					retryAttempts,
-					retryDelayMs
-				}
-			}));
-		},
-		buildPositionsCollector: ({ options: { maxBatchSize = 1e3, retryAttempts, retryDelayMs } = {} } = {}) => {
-			return createCollector("positions", (p) => collectPositions({
-				...p,
-				collector: "positions",
-				options: {
-					maxBatchSize,
-					retryAttempts,
-					retryDelayMs,
-					blockWindow
-				}
-			}));
-		}
-	};
-}
-
-//#endregion
-//#region src/indexer/collectors/Collectors.ts
-const from$2 = (parameters) => {
-	const { client, db, gatekeeper, maxBatchSize, maxBlockNumber, blockWindow, interval, retryAttempts, retryDelayMs } = parameters;
-	const collectorBuilder = createBuilder({
-		client,
-		db,
-		gatekeeper,
-		options: {
-			maxBlockNumber,
-			blockWindow,
-			interval
-		}
-	});
-	return {
-		offersCollector: collectorBuilder.buildOffersCollector({ options: { maxBatchSize } }),
-		consumedEventsCollector: collectorBuilder.buildConsumedEventsCollector({ options: { maxBatchSize } }),
-		pricesCollector: collectorBuilder.buildPricesCollector({ options: {
-			maxBatchSize,
-			retryAttempts,
-			retryDelayMs
-		} }),
-		positionsCollector: collectorBuilder.buildPositionsCollector({ options: {
-			maxBatchSize,
-			retryAttempts,
-			retryDelayMs
-		} })
-	};
-};
-
-//#endregion
-//#region src/indexer/Indexer.ts
-function from$1(config) {
-	const { client, gatekeeper, db, interval = 1e4, maxBatchSize = 1e3, maxBlockNumber, blockWindow, retryAttempts, retryDelayMs } = config;
-	const { offersCollector, consumedEventsCollector, positionsCollector, pricesCollector } = from$2({
-		client,
-		db,
-		gatekeeper,
-		maxBatchSize,
-		maxBlockNumber,
-		blockWindow,
-		interval,
-		retryAttempts,
-		retryDelayMs
-	});
-	return create$18({
-		client,
-		collectors: [
-			offersCollector,
-			consumedEventsCollector,
-			positionsCollector,
-			pricesCollector
-		]
-	});
-}
-function create$18(params) {
-	const { collectors, client } = params;
-	const indexerId = `${client.chain.id.toString()}.indexer`;
-	const tracer = getTracer(`router.${indexerId}`);
-	const iterators = collectors.map((collector) => collector.collect());
-	const next = async () => {
-		await startActiveSpan(tracer, `${indexerId}.next`, async () => {
-			await Promise.all(iterators.map((iterator) => iterator.next()));
-		});
-	};
-	const _return = async () => {
-		await Promise.all(iterators.map(async (iterator) => iterator.return()));
-	};
-	return {
-		start: () => {
-			const stops = collectors.map((collector) => start(collector));
-			return () => {
-				stops.forEach((stop) => {
-					stop();
-				});
-			};
-		},
-		next,
-		return: _return
-	};
-}
-
-//#endregion
-//#region src/indexer/collectors/Admin.ts
-function create$17(parameters) {
-	const collector = "admin";
-	const { client, db, options: { maxBatchSize = 25, maxBlockNumber } = {} } = parameters;
-	const maxBlockNumberBI = maxBlockNumber !== void 0 ? BigInt(maxBlockNumber) : void 0;
-	let finalizedBlock = null;
-	let unfinalizedBlocks = [];
-	let initialized = false;
-	const logger = getLogger();
-	let isMaxBlockNumberReached = false;
-	let tick = 0;
-	return { syncBlock: async () => {
-		if (!initialized) {
-			await Promise.all(names.map((collectorName) => db.blocks.init({
-				chainId: client.chain.id,
-				collectorName
-			})));
-			initialized = true;
-		}
-		if (isMaxBlockNumberReached) return true;
-		const head = await client.getBlock({
-			blockTag: "latest",
-			includeTransactions: false
-		});
-		await db.transaction(async (dbTx) => {
-			const { epoch, blockNumber: latestSavedBlockNumber } = await dbTx.blocks.getChain(client.chain.id);
-			if (maxBlockNumberBI !== void 0 && head.number >= maxBlockNumberBI) {
-				logger.info({
-					msg: `Head is greater than max block number`,
-					collector,
-					chainId: client.chain.id,
-					block_number: head.number,
-					max_block_number: maxBlockNumber
-				});
-				await dbTx.blocks.handleReorg({
-					chainId: client.chain.id,
-					blockNumber: maxBlockNumber,
-					epoch: epoch + 1n
-				});
-				isMaxBlockNumberReached = true;
-				return isMaxBlockNumberReached;
-			}
-			finalizedBlock = await fetchFinalizedBlock({
-				tick,
-				client,
-				logger,
-				collector,
-				unfinalizedBlocks,
-				previousFinalizedBlock: finalizedBlock
-			});
-			tick++;
-			let { block: returnedBlock, didReorgHappened, unfinalizedBlocks: newUnfinalizedBlocks } = await reconcile({
-				client,
-				block: head,
-				unfinalizedBlocks,
-				finalizedBlock,
-				logger,
-				collector,
-				maxBatchSize
-			});
-			unfinalizedBlocks = newUnfinalizedBlocks;
-			const blockNumber = Number(returnedBlock.number);
-			didReorgHappened = didReorgHappened || blockNumber < latestSavedBlockNumber;
-			if (didReorgHappened) await dbTx.blocks.handleReorg({
-				chainId: client.chain.id,
-				blockNumber,
-				epoch: epoch + 1n
-			});
-			else await dbTx.blocks.advanceChain({
-				chainId: client.chain.id,
-				blockNumber,
-				epoch
-			});
-		});
-		return isMaxBlockNumberReached;
-	} };
-}
-const commonAncestor = (block, unfinalizedBlocks) => {
-	const parent = unfinalizedBlocks.find((b) => b.hash === block.parentHash);
-	if (parent) return parent;
-	return null;
-};
-const fetchFinalizedBlock = async (parameters) => {
-	let { tick, client, logger, collector, unfinalizedBlocks, previousFinalizedBlock } = parameters;
-	let finalizedBlock = previousFinalizedBlock;
-	if (tick % 20 === 0 || previousFinalizedBlock === null) {
-		finalizedBlock = await client.getBlock({
-			blockTag: "finalized",
-			includeTransactions: false
-		});
-		if (finalizedBlock === null || finalizedBlock.number === null) {
-			const msg = "Failed to get finalized block";
-			logger.fatal({
-				collector,
-				chainId: client.chain.id,
-				msg
-			});
-			throw new Error(msg);
-		}
-		unfinalizedBlocks = unfinalizedBlocks.filter((b) => b.number >= finalizedBlock.number);
-	}
-	if (finalizedBlock.number === null || finalizedBlock.hash === null || finalizedBlock.parentHash === null) {
-		const msg = "Failed to get finalized block";
-		logger.fatal({
-			collector,
-			chainId: client.chain.id,
-			msg
-		});
-		throw new Error(msg);
-	}
-	return {
-		hash: finalizedBlock.hash,
-		number: finalizedBlock.number,
-		parentHash: finalizedBlock.parentHash
-	};
-};
-const reconcile = async (parameters) => {
-	let { client, block, unfinalizedBlocks, finalizedBlock, logger, collector, maxBatchSize } = parameters;
-	const chain = client.chain;
-	if (block.hash === null || block.number === null || block.parentHash === null) throw new Error("Failed to get block");
-	const latestBlock = unfinalizedBlocks[unfinalizedBlocks.length - 1];
-	if (latestBlock === void 0) {
-		const newBlock = {
-			hash: block.hash,
-			number: block.number,
-			parentHash: block.parentHash
-		};
-		unfinalizedBlocks.push(newBlock);
-		return {
-			block: newBlock,
-			didReorgHappened: false,
-			unfinalizedBlocks
-		};
-	}
-	if (latestBlock.hash === block.hash) return {
-		block: latestBlock,
-		didReorgHappened: false,
-		unfinalizedBlocks
-	};
-	if (latestBlock.number >= block.number) {
-		const ancestor = commonAncestor(block, unfinalizedBlocks) || finalizedBlock;
-		logger.info({
-			msg: `Reorg detected, latestBlock.number >= block.number`,
-			collector,
-			chain_id: chain.id,
-			ancestor: ancestor.number,
-			latest_block_number: latestBlock.number,
-			block_number: block.number
-		});
-		unfinalizedBlocks = unfinalizedBlocks.filter((b) => b.number <= ancestor.number);
-		return {
-			block: ancestor,
-			didReorgHappened: true,
-			unfinalizedBlocks
-		};
-	}
-	if (latestBlock.number + 1n < block.number) {
-		logger.debug({
-			collector,
-			chain_id: chain.id,
-			block_range: [latestBlock.number, block.number],
-			msg: `Missing blocks`
-		});
-		const missingBlockNumbers = (() => {
-			const missingBlockNumbers = [];
-			let start = latestBlock.number + 1n;
-			const threshold = latestBlock.number + BigInt(maxBatchSize) > block.number ? block.number : latestBlock.number + BigInt(maxBatchSize);
-			while (start < threshold) {
-				missingBlockNumbers.push(start);
-				start = start + 1n;
-			}
-			return missingBlockNumbers;
-		})();
-		const missingBlocks = await Promise.all(missingBlockNumbers.map((blockNumber) => retry(async () => await client.getBlock({
-			blockNumber,
-			includeTransactions: false
-		}))));
-		for (const missingBlock of missingBlocks) {
-			const { block: returnedBlock, didReorgHappened, unfinalizedBlocks: newUnfinalizedBlocks } = await reconcile({
-				client,
-				block: missingBlock,
-				unfinalizedBlocks,
-				finalizedBlock,
-				logger,
-				collector,
-				maxBatchSize
-			});
-			if (returnedBlock.number !== missingBlock.number) return {
-				block: returnedBlock,
-				didReorgHappened,
-				unfinalizedBlocks: newUnfinalizedBlocks
-			};
-		}
-		return reconcile({
-			client,
-			block,
-			unfinalizedBlocks,
-			finalizedBlock,
-			logger,
-			collector,
-			maxBatchSize
-		});
-	}
-	if (block.parentHash !== latestBlock.hash) {
-		const ancestor = commonAncestor(block, unfinalizedBlocks) || finalizedBlock;
-		logger.info({
-			msg: `Reorg detected, block parent hash !== latest block hash`,
-			collector,
-			chain_id: chain.id,
-			ancestor: ancestor.number,
-			latest_block_number: latestBlock.number,
-			block_number: block.number
-		});
-		unfinalizedBlocks = unfinalizedBlocks.filter((b) => b.number <= ancestor.number);
-		return {
-			block: ancestor,
-			didReorgHappened: true,
-			unfinalizedBlocks
-		};
-	}
-	const newBlock = {
-		hash: block.hash,
-		number: block.number,
-		parentHash: block.parentHash
-	};
-	unfinalizedBlocks.push(newBlock);
-	return {
-		block: newBlock,
-		didReorgHappened: false,
-		unfinalizedBlocks
-	};
-};
-
-//#endregion
-//#region src/indexer/collectors/Collector.ts
-const names = [
-	"offers",
-	"consumed_events",
-	"positions",
-	"prices"
-];
-function create$16({ name, collect, client, db, options }) {
-	const admin = create$17({
-		client,
-		db,
-		options
-	});
-	return {
-		name,
-		chain: client.chain,
-		client,
-		db,
-		interval: options.interval ?? 1e4,
-		collect: async function* () {
-			const collector = name;
-			const chain = client.chain;
-			const logger = getLogger();
-			const collectorId = `${client.chain.id.toString()}.collector.${collector}`;
-			const tracer = getTracer(`router.${collectorId}`);
-			logger.info({
-				msg: `Collector started`,
-				collector,
-				chain_id: chain.id
-			});
-			let iterator = null;
-			let lastBlockNumber;
-			while (true) try {
-				if (iterator === null) iterator = await startActiveSpan(tracer, `${collectorId}.init`, async () => {
-					const { collector: collectorBlock } = await db.blocks.init({
-						collectorName: name,
-						chainId: chain.id
-					});
-					lastBlockNumber = collectorBlock.blockNumber;
-					return collect({
-						client,
-						collector: name,
-						epoch: collectorBlock.epoch,
-						lastBlockNumber,
-						db
-					});
-				});
-				if (await startActiveSpan(tracer, `${collectorId}.syncBlock`, async (span) => {
-					const isMaxBlockNumberReached = await admin.syncBlock();
-					span.setAttribute("collector.is_max_block_reached", isMaxBlockNumberReached);
-					return isMaxBlockNumberReached;
-				}) && options.maxBlockNumber !== void 0 && lastBlockNumber !== void 0 && options.maxBlockNumber === lastBlockNumber) return;
-				const { blockNumber, done } = await startActiveSpan(tracer, `${collectorId}.next`, async () => {
-					if (iterator === null) throw new Error("Iterator is not initialized");
-					const { value: blockNumber, done } = await iterator.next();
-					return {
-						blockNumber,
-						done
-					};
-				});
-				if (done) iterator = null;
-				else {
-					lastBlockNumber = blockNumber;
-					yield blockNumber;
-				}
-			} catch (err) {
-				const isError = err instanceof Error;
-				logger.error({
-					msg: "Collector error",
-					collector,
-					chain_id: chain.id,
-					error: isError ? err.message : String(err),
-					stack: isError ? err.stack : void 0
-				});
-			}
-		}
-	};
-}
-/** Start a collector with its own polling cadence based on chain head lag.
-* @param collector - The collector to start.
-* @returns A function to stop the collector.
-*/
-function start(collector) {
-	let stopped = false;
-	const it = collector.collect();
-	const logger = getLogger();
-	const collectorId = `${collector.chain.id.toString()}.collector.${collector.name}`;
-	const tracer = getTracer(`router.${collectorId}`);
-	const blocks = collector.db.blocks;
-	let initialized = false;
-	(async () => {
-		while (!stopped) try {
-			await startActiveSpan(tracer, `${collectorId}.poll`, async () => {
-				if (!initialized) {
-					await blocks.init({
-						chainId: collector.chain.id,
-						collectorName: collector.name
-					});
-					initialized = true;
-				}
-				const [block, { blockNumber: collectorBlockNumber }] = await Promise.all([collector.client.getBlock({
-					blockTag: "latest",
-					includeTransactions: false
-				}), blocks.getCollector({
-					collectorName: collector.name,
-					chainId: collector.chain.id
-				})]);
-				const delay = Number(block.number) > collectorBlockNumber + 10 ? 250 : collector.interval;
-				const waitSpan = tracer.startSpan(`${collectorId}.wait`);
-				try {
-					await wait(delay);
-				} finally {
-					waitSpan.end();
-				}
-				await it.next();
-			});
-		} catch (err) {
-			const error = err instanceof Error ? err : new Error(String(err));
-			logger.error({
-				msg: "Collector polling error",
-				collector: collector.name,
-				chain_id: collector.chain.id,
-				err: error
-			});
-		}
-		await it.return();
-	})();
-	return () => {
-		stopped = true;
-	};
-}
-
-//#endregion
-//#region src/database/drizzle/VERSION.ts
-const VERSION = "router_v1.6";
+//#region src/database/drizzle/VERSION.ts
+const VERSION = "router_v1.6";
 
 //#endregion
 //#region src/database/drizzle/schema.ts
@@ -7274,6 +5551,1654 @@ const merklePaths = s.table(EnumTableName.MERKLE_PATHS, {
 	createdAt: timestamp("created_at").defaultNow().notNull()
 }, (table) => [index("merkle_paths_tree_root_idx").on(table.treeRoot)]);
 
+//#endregion
+//#region src/indexer/collectors/CollectFunctions/collectConsumedEvents.ts
+const buildGroupKey = (parameters) => {
+	return `${parameters.chainId}-${parameters.maker.toLowerCase()}-${parameters.group.toLowerCase()}`;
+};
+async function* collectConsumedEvents(parameters) {
+	let { db, collector, client, lastBlockNumber: blockNumber, epoch, options: { maxBatchSize = 1e3, blockWindow } = {} } = parameters;
+	const logger = getLogger();
+	let startBlock = blockNumber;
+	let reorgDetected = false;
+	const { blockNumber: latestBlockNumberChain } = await db.blocks.getChain(client.chain.id);
+	const stream = streamLogs({
+		client,
+		contractAddress: client.chain.custom.morpho.address,
+		blockNumberGte: blockNumber,
+		blockNumberLte: latestBlockNumberChain,
+		order: "asc",
+		options: {
+			maxBatchSize,
+			blockWindow
+		}
+	});
+	for await (const { logs, blockNumber: lastStreamBlockNumber } of stream) {
+		const parsedLogs = parseEventLogs({
+			abi: [consumedEvent, takeEvent],
+			logs,
+			strict: false
+		});
+		const normalizedLogs = [];
+		const groups$3 = /* @__PURE__ */ new Map();
+		const eventIds = /* @__PURE__ */ new Set();
+		const recordLog = (log) => {
+			normalizedLogs.push(log);
+			eventIds.add(log.id);
+			const groupKey = buildGroupKey({
+				chainId: log.chainId,
+				maker: log.maker,
+				group: log.group
+			});
+			if (!groups$3.has(groupKey)) groups$3.set(groupKey, {
+				chainId: log.chainId,
+				maker: log.maker.toLowerCase(),
+				group: log.group.toLowerCase()
+			});
+		};
+		for (const rawLog of parsedLogs) {
+			if (rawLog.blockNumber === null || rawLog.logIndex === null || rawLog.transactionHash === null) {
+				logger.debug({
+					collector,
+					chainId: client.chain.id,
+					msg: "Skipping log because it is missing required fields"
+				});
+				continue;
+			}
+			if (rawLog.eventName === consumedEvent.name) {
+				const consumeArgs = rawLog.args;
+				if (consumeArgs.user === void 0 || consumeArgs.group === void 0 || consumeArgs.amount === void 0) {
+					logger.debug({
+						collector,
+						chainId: client.chain.id,
+						msg: "Skipping Consume log because it is missing required args"
+					});
+					continue;
+				}
+				recordLog({
+					kind: "consume",
+					id: `${rawLog.blockNumber.toString()}-${rawLog.logIndex.toString()}-${client.chain.id}-${rawLog.transactionHash}`,
+					chainId: client.chain.id,
+					maker: consumeArgs.user,
+					group: consumeArgs.group,
+					amount: consumeArgs.amount,
+					blockNumber: Number(rawLog.blockNumber)
+				});
+				continue;
+			}
+			if (rawLog.eventName === takeEvent.name) {
+				const takeArgs = rawLog.args;
+				if (takeArgs.maker === void 0 || takeArgs.group === void 0 || takeArgs.consumed === void 0) {
+					logger.debug({
+						collector,
+						chainId: client.chain.id,
+						msg: "Skipping Take log because it is missing required args"
+					});
+					continue;
+				}
+				recordLog({
+					kind: "take",
+					id: `${rawLog.blockNumber.toString()}-${rawLog.logIndex.toString()}-${client.chain.id}-${rawLog.transactionHash}`,
+					chainId: client.chain.id,
+					maker: takeArgs.maker,
+					group: takeArgs.group,
+					consumed: takeArgs.consumed,
+					blockNumber: Number(rawLog.blockNumber)
+				});
+			}
+		}
+		await db.transaction(async (dbTx) => {
+			const existingEventIds = /* @__PURE__ */ new Set();
+			if (eventIds.size > 0) {
+				const ids = Array.from(eventIds);
+				for (let index = 0; index < ids.length; index += 500) {
+					const slice = ids.slice(index, index + 500);
+					const { rows } = await dbTx.execute(sql`
+            SELECT event_id
+            FROM ${consumedEvents}
+            WHERE event_id IN (${sql.join(slice.map((id) => sql`${id}`), sql`,`)});
+          `);
+					for (const row of rows) existingEventIds.add(row.event_id);
+				}
+			}
+			const consumedByGroup = /* @__PURE__ */ new Map();
+			if (groups$3.size > 0) {
+				const groupList = Array.from(groups$3.values());
+				for (let index = 0; index < groupList.length; index += 500) {
+					const slice = groupList.slice(index, index + 500);
+					const { rows } = await dbTx.execute(sql`
+            WITH targets(chain_id, maker, "group") AS (
+              VALUES ${sql.join(slice.map((group) => sql`(${group.chainId}::bigint, ${group.maker.toLowerCase()}::varchar(42), ${group.group.toLowerCase()}::varchar(66))`), sql`,`)}
+            )
+            SELECT
+              targets.chain_id,
+              targets.maker,
+              targets."group",
+              COALESCE(g.consumed, 0)::numeric AS consumed
+            FROM targets
+            LEFT JOIN ${groups} g
+              ON g.chain_id = targets.chain_id
+             AND g.maker = targets.maker
+             AND g."group" = targets."group";
+          `);
+					for (const row of rows) {
+						const groupKey = buildGroupKey({
+							chainId: Number(row.chain_id),
+							maker: row.maker,
+							group: row.group
+						});
+						consumedByGroup.set(groupKey, BigInt(row.consumed ?? "0"));
+					}
+				}
+			}
+			const events = [];
+			for (const log of normalizedLogs) {
+				if (existingEventIds.has(log.id)) continue;
+				const groupKey = buildGroupKey({
+					chainId: log.chainId,
+					maker: log.maker,
+					group: log.group
+				});
+				const previousConsumed = consumedByGroup.get(groupKey) ?? 0n;
+				if (log.kind === "consume") {
+					events.push({
+						id: log.id,
+						chainId: log.chainId,
+						maker: log.maker,
+						group: log.group,
+						amount: log.amount,
+						blockNumber: log.blockNumber
+					});
+					consumedByGroup.set(groupKey, previousConsumed + log.amount);
+					continue;
+				}
+				const delta = log.consumed - previousConsumed;
+				if (delta <= 0n) {
+					logger.debug({
+						collector,
+						chainId: client.chain.id,
+						msg: "Skipping Take log because consumed did not increase",
+						previous_consumed: previousConsumed.toString(),
+						consumed: log.consumed.toString()
+					});
+					continue;
+				}
+				events.push({
+					id: log.id,
+					chainId: log.chainId,
+					maker: log.maker,
+					group: log.group,
+					amount: delta,
+					blockNumber: log.blockNumber
+				});
+				consumedByGroup.set(groupKey, log.consumed);
+			}
+			try {
+				await dbTx.consumed.create(events);
+				if (events.length > 0) logger.info({
+					msg: `Events indexed`,
+					collector,
+					count: events.length,
+					chain_id: client.chain.id,
+					block_range: [startBlock, lastStreamBlockNumber]
+				});
+			} catch (err) {
+				logger.error({
+					err,
+					msg: "Failed to process consumed events"
+				});
+			}
+			blockNumber = lastStreamBlockNumber;
+			try {
+				await dbTx.blocks.advanceCollector({
+					collectorName: collector,
+					chainId: client.chain.id,
+					blockNumber,
+					epoch
+				});
+			} catch (_) {
+				try {
+					const ancestor = await dbTx.blocks.getCollector({
+						collectorName: collector,
+						chainId: client.chain.id
+					});
+					blockNumber = ancestor.blockNumber;
+					const deleted = await dbTx.consumed.delete({
+						chainId: client.chain.id,
+						blockNumberGte: blockNumber + 1
+					});
+					logger.info({
+						collector,
+						chain_id: client.chain.id,
+						msg: `Reorg detected, events deleted`,
+						count: deleted,
+						block_number: blockNumber
+					});
+					await dbTx.blocks.advanceCollector({
+						collectorName: collector,
+						chainId: client.chain.id,
+						blockNumber,
+						epoch: ancestor.epoch
+					});
+					reorgDetected = true;
+				} catch (err) {
+					const msg = "Failed to delete consumed events when handling reorg.";
+					logger.error({
+						collector,
+						chainId: client.chain.id,
+						msg,
+						err
+					});
+					throw new Error(msg, { cause: err });
+				}
+			}
+		});
+		if (reorgDetected) return;
+		yield blockNumber;
+		startBlock = blockNumber;
+	}
+}
+
+//#endregion
+//#region src/indexer/collectors/CollectFunctions/collectOffers.ts
+async function* collectOffersV2(parameters) {
+	let { db, collector, client, lastBlockNumber: blockNumber, gatekeeper, options: { maxBatchSize = 1e3, blockWindow } = {} } = parameters;
+	const logger = getLogger();
+	let startBlock = blockNumber;
+	let reorgDetected = false;
+	if (client.chain.custom.morpho.address.toLowerCase() === zeroAddress) {
+		const msg = "Morpho V2 address is zero, signature verification will fail. Please set the Morpho V2 address in the chain configuration.";
+		logger.error({
+			msg,
+			chain_id: client.chain.id
+		});
+		throw new Error(msg);
+	}
+	const signatureDomain = {
+		chainId: client.chain.id,
+		verifyingContract: client.chain.custom.morpho.address
+	};
+	const { blockNumber: latestBlockNumberChain } = await db.blocks.getChain(client.chain.id);
+	const stream = streamLogs({
+		client,
+		contractAddress: client.chain.custom.mempool.address,
+		event: {
+			type: "event",
+			name: "Event",
+			inputs: [{
+				name: "data",
+				type: "bytes",
+				indexed: false,
+				internalType: "bytes"
+			}],
+			anonymous: false
+		},
+		blockNumberGte: blockNumber,
+		blockNumberLte: latestBlockNumberChain,
+		order: "asc",
+		options: {
+			maxBatchSize,
+			blockWindow
+		}
+	});
+	for await (const { logs, blockNumber: lastStreamBlockNumber } of stream) {
+		blockNumber = lastStreamBlockNumber;
+		const decodedTrees = [];
+		for (const log of logs) {
+			if (!log) continue;
+			const [payload] = decodeAbiParameters([{ type: "bytes" }], log.data);
+			try {
+				const { tree, signature, signer } = await decode(payload, signatureDomain);
+				const signerMismatch = tree.offers.find((offer) => offer.maker.toLowerCase() !== signer.toLowerCase());
+				if (signerMismatch) {
+					logger.debug({
+						msg: "Tree rejected: signer mismatch",
+						reason: "signer_mismatch",
+						signer,
+						maker: signerMismatch.maker,
+						chain_id: client.chain.id
+					});
+					continue;
+				}
+				decodedTrees.push({
+					tree,
+					signature,
+					signer,
+					blockNumber: Number(log.blockNumber)
+				});
+			} catch (err) {
+				const reason = err instanceof DecodeError && err.message.includes("signature") ? "invalid_signature" : "decode_failed";
+				logger.debug({
+					msg: "Tree decode failed",
+					reason,
+					chain_id: client.chain.id,
+					err: err instanceof Error ? err.message : String(err)
+				});
+			}
+		}
+		await db.transaction(async (dbTx) => {
+			const { epoch, blockNumber: latestBlockNumber } = await dbTx.blocks.getChain(client.chain.id);
+			const treesToInsert = [];
+			let totalValidOffers = 0;
+			const offersWithBlock = [];
+			for (const { tree, signature, blockNumber: treeBlockNumber } of decodedTrees) try {
+				const allowedResults = await gatekeeper.isAllowed(tree.offers);
+				const hasBlockWindowViolation = treeBlockNumber > latestBlockNumber;
+				if (!(allowedResults.issues.length === 0 && allowedResults.valid.length === tree.offers.length) || hasBlockWindowViolation) {
+					if (allowedResults.issues.length > 0) {
+						const hasMixedMaker = allowedResults.issues.some((i) => i.ruleName === "mixed_maker");
+						logger.debug({
+							msg: "Tree offers rejected by gatekeeper",
+							reason: hasMixedMaker ? "mixed_maker" : "gatekeeper_rejected",
+							chain_id: client.chain.id,
+							issues_count: allowedResults.issues.length
+						});
+					} else if (hasBlockWindowViolation) logger.debug({
+						msg: "Tree rejected: offers outside block window",
+						reason: "block_window",
+						chain_id: client.chain.id
+					});
+					continue;
+				}
+				treesToInsert.push({
+					tree,
+					signature
+				});
+				totalValidOffers += tree.offers.length;
+				offersWithBlock.push(...tree.offers.map((offer) => ({
+					offer,
+					blockNumber: treeBlockNumber
+				})));
+			} catch (err) {
+				const error = err instanceof Error ? err : new Error(String(err));
+				logger.error({
+					err: error,
+					msg: "Gatekeeper validation failed",
+					chain_id: client.chain.id
+				});
+				throw new Error("Gatekeeper validation failed", { cause: error });
+			}
+			const dependencies = buildOfferDependencies$1(offersWithBlock);
+			await dbTx.oracles.upsert(dependencies.oracles);
+			await dbTx.obligations.create(dependencies.obligations);
+			await dbTx.groups.create(dependencies.groups);
+			const insertedHashes = await dbTx.offers.create(dependencies.offerBatches);
+			if (treesToInsert.length > 0) await dbTx.trees.create(treesToInsert);
+			const insertedOffers = filterInsertedOffers({
+				offers: offersWithBlock,
+				hashes: insertedHashes
+			});
+			const { callbacks, positions, lots } = decodeCallbacks({
+				chainId: client.chain.id,
+				offers: insertedOffers
+			});
+			if (positions.length > 0) await dbTx.positions.upsert(positions);
+			if (callbacks.length > 0) await dbTx.callbacks.upsert(callbacks);
+			if (lots.length > 0) await dbTx.lots.create(lots);
+			try {
+				await dbTx.blocks.advanceCollector({
+					collectorName: collector,
+					chainId: client.chain.id,
+					blockNumber,
+					epoch
+				});
+				if (totalValidOffers > 0) logger.info({
+					msg: `New offers`,
+					collector,
+					count: totalValidOffers,
+					trees_count: treesToInsert.length,
+					chain_id: client.chain.id,
+					block_range: [startBlock, lastStreamBlockNumber]
+				});
+			} catch (_) {
+				try {
+					const ancestor = await dbTx.blocks.getCollector({
+						collectorName: collector,
+						chainId: client.chain.id
+					});
+					blockNumber = ancestor.blockNumber;
+					const deleted = await dbTx.offers.delete({
+						blockNumberGte: blockNumber + 1,
+						chainId: client.chain.id
+					});
+					logger.info({
+						collector,
+						chain_id: client.chain.id,
+						msg: `Reorg detected, offers deleted`,
+						count: deleted,
+						block_number: blockNumber
+					});
+					await dbTx.blocks.advanceCollector({
+						collectorName: collector,
+						chainId: client.chain.id,
+						blockNumber,
+						epoch: ancestor.epoch
+					});
+					reorgDetected = true;
+				} catch (err) {
+					const msg = "Failed to delete offers when handling reorg.";
+					logger.error({
+						collector,
+						chainId: client.chain.id,
+						msg,
+						err
+					});
+					throw new Error(msg);
+				}
+			}
+		});
+		if (reorgDetected) return;
+		yield blockNumber;
+		startBlock = blockNumber;
+	}
+}
+function decodeCallbacks(parameters) {
+	const { offers } = parameters;
+	if (offers.length === 0) return {
+		callbacks: [],
+		positions: [],
+		lots: []
+	};
+	const callbacks = [];
+	const positions = [];
+	const lots = [];
+	for (const { offer, blockNumber: offerBlockNumber } of offers) {
+		if (!offer.buy) continue;
+		if (!isEmptyCallback(offer)) continue;
+		const loanToken = offer.loanToken.toLowerCase();
+		positions.push(from$10({
+			chainId: offer.chainId,
+			contract: loanToken,
+			user: offer.maker,
+			type: Type.ERC20,
+			asset: loanToken,
+			blockNumber: offerBlockNumber
+		}));
+		lots.push({
+			positionChainId: offer.chainId,
+			positionContract: loanToken,
+			positionUser: offer.maker,
+			group: offer.group,
+			size: offer.assets
+		});
+		callbacks.push({
+			offerHash: hash(offer),
+			callbacks: [{
+				chainId: offer.chainId,
+				contract: loanToken,
+				user: offer.maker,
+				amount: offer.assets
+			}]
+		});
+	}
+	return {
+		callbacks,
+		positions,
+		lots
+	};
+}
+function buildOfferDependencies$1(offers) {
+	const obligationsById = /* @__PURE__ */ new Map();
+	const oraclesByKey = /* @__PURE__ */ new Map();
+	const groupsByKey = /* @__PURE__ */ new Map();
+	const offersByBlock = /* @__PURE__ */ new Map();
+	for (const { offer, blockNumber } of offers) {
+		const list = offersByBlock.get(blockNumber) ?? [];
+		list.push(offer);
+		offersByBlock.set(blockNumber, list);
+		const obligationId$2 = obligationId(offer);
+		if (!obligationsById.get(obligationId$2)) obligationsById.set(obligationId$2, from$13({
+			chainId: offer.chainId,
+			loanToken: offer.loanToken,
+			maturity: offer.maturity,
+			collaterals: offer.collaterals
+		}));
+		for (const collateral of offer.collaterals) {
+			const oracleKey = `${offer.chainId}-${collateral.oracle}`.toLowerCase();
+			if (!oraclesByKey.has(oracleKey)) oraclesByKey.set(oracleKey, from$11({
+				chainId: offer.chainId,
+				address: collateral.oracle,
+				price: null,
+				blockNumber
+			}));
+		}
+		const groupKey = `${offer.chainId}-${offer.maker}-${offer.group}`.toLowerCase();
+		if (!groupsByKey.has(groupKey)) groupsByKey.set(groupKey, {
+			chainId: offer.chainId,
+			maker: offer.maker,
+			group: offer.group,
+			blockNumber
+		});
+	}
+	return {
+		obligations: Array.from(obligationsById.values()),
+		oracles: Array.from(oraclesByKey.values()),
+		groups: Array.from(groupsByKey.values()),
+		offerBatches: Array.from(offersByBlock.entries()).map(([blockNumber, items]) => ({
+			blockNumber,
+			offers: items
+		}))
+	};
+}
+function filterInsertedOffers(parameters) {
+	if (parameters.hashes.length === 0) return [];
+	const inserted = new Set(parameters.hashes.map((hash) => hash.toLowerCase()));
+	const seen = /* @__PURE__ */ new Set();
+	const filtered = [];
+	for (const entry of parameters.offers) {
+		const hash$2 = hash(entry.offer).toLowerCase();
+		if (!inserted.has(hash$2)) continue;
+		if (seen.has(hash$2)) continue;
+		seen.add(hash$2);
+		filtered.push(entry);
+	}
+	return filtered;
+}
+
+//#endregion
+//#region src/indexer/collectors/fetchers/fetchOraclePrices.ts
+/**
+* Fetches prices from multiple oracle contracts using multicall.
+*
+* - Executes `price()` on {@link Abi.Oracle} for each {@link Address}.
+* - Requires a client supporting {@link PublicActions.multicall | multicall}.
+*
+* @param parameters - {@link fetchOraclePrices.Parameters} including the list of oracle
+* {@link Address | addresses}, fetch options, and the multicall-enabled client.
+* @returns {@link fetchOraclePrices.ReturnType} mapping {@link Address} to `bigint` price.
+*/
+async function fetchOraclePrices(parameters) {
+	const { client, oracles, options } = parameters;
+	if (oracles.length === 0) return /* @__PURE__ */ new Map();
+	const batchSize = Math.max(1, options?.batchSize ?? 5e3);
+	const retryAttempts = Math.max(1, options?.retryAttempts ?? 3);
+	const retryDelayMs = Math.max(0, options?.retryDelayMs ?? 50);
+	const blockNumber = options?.blockNumber ? BigInt(options.blockNumber) : void 0;
+	const out = /* @__PURE__ */ new Map();
+	for (const oraclesBatch of batch$1(oracles, batchSize)) {
+		const priceCalls = [];
+		for (const oracle of oraclesBatch) priceCalls.push({
+			address: oracle,
+			abi: Oracle,
+			functionName: "price",
+			args: []
+		});
+		const prices = await batchMulticall({
+			client,
+			calls: priceCalls,
+			batchSize,
+			retryAttempts,
+			retryDelayMs,
+			blockNumber
+		});
+		for (let i = 0; i < oraclesBatch.length; i++) {
+			const oracle = oraclesBatch[i];
+			const price = prices[i];
+			out.set(oracle, price);
+		}
+	}
+	return out;
+}
+
+//#endregion
+//#region src/indexer/collectors/fetchers/snapshotERC20Positions.ts
+/**
+* Fetches ERC20 balances for positions at a given block number and returns the positions with the updated balances.
+* @notice This method does not mutate positions and returns a new array.
+*
+* @param parameters - {@link snapshotERC20Positions.Parameters}
+* @returns Positions - {@link snapshotERC20Positions.ReturnType}
+*/
+async function snapshotERC20Positions(parameters) {
+	const { positions: oldPositions, blockNumber, options: { maxBatchSize = 1e3, retryAttempts = 5, retryDelayMs = 500 } = {} } = parameters;
+	if (oldPositions.length === 0) return [];
+	const calls = [];
+	for (const position of oldPositions) calls.push({
+		address: position.contract,
+		abi: erc20Abi,
+		functionName: "balanceOf",
+		args: [position.user]
+	});
+	const balances = await batchMulticall({
+		client: parameters.client,
+		calls,
+		blockNumber: BigInt(blockNumber),
+		batchSize: maxBatchSize,
+		retryAttempts,
+		retryDelayMs
+	});
+	const positions = [];
+	for (let i = 0; i < balances.length; i++) {
+		const oldPosition = oldPositions[i];
+		if (!oldPosition) continue;
+		positions.push({
+			...oldPosition,
+			balance: balances[i],
+			blockNumber
+		});
+	}
+	return positions;
+}
+
+//#endregion
+//#region src/indexer/collectors/fetchers/snapshotVaultPositions.ts
+/**
+* Fetches vault shares for users at a given block number, converts them to assets and returns the positions with the updated balances.
+* @notice This method does not mutate positions and returns a new array.
+*
+* @param parameters - {@link snapshotVaultPositions.Parameters}
+* @returns Positions - {@link snapshotVaultPositions.ReturnType}
+*/
+async function snapshotVaultPositions(parameters) {
+	const logger = getLogger();
+	const { client, positions: oldPositions, blockNumber, options: { maxBatchSize = 1e3, retryAttempts = 5, retryDelayMs = 500 } = {} } = parameters;
+	const calls = [];
+	const contracts = /* @__PURE__ */ new Map();
+	const positions = structuredClone(oldPositions);
+	for (const position of positions) {
+		calls.push({
+			address: position.contract,
+			abi: MetaMorpho,
+			functionName: "balanceOf",
+			args: [position.user],
+			convertToAssets: (shares) => {
+				const contract = contracts.get(position.contract.toLowerCase());
+				if (!contract) return;
+				if (contract.decimalsOffset === void 0 || contract.totalAssets === void 0 || contract.totalSupply === void 0) return;
+				try {
+					position.balance = convertToAssets({
+						shares,
+						totalAssets: contract.totalAssets,
+						totalSupply: contract.totalSupply,
+						decimalsOffset: contract.decimalsOffset
+					});
+					position.asset = contract.asset;
+					position.blockNumber = blockNumber;
+				} catch (err) {
+					if (err instanceof DenominatorIsZeroError) {
+						logger.error({
+							msg: "Failed to convert shares to assets",
+							chain_id: client.chain.id,
+							block_number: blockNumber,
+							position_contract: position.contract,
+							position_user: position.user,
+							shares,
+							err
+						});
+						return;
+					}
+					throw err;
+				}
+			}
+		});
+		if (contracts.has(position.contract.toLowerCase())) continue;
+		calls.push({
+			address: position.contract,
+			abi: MetaMorpho,
+			functionName: "DECIMALS_OFFSET",
+			args: []
+		}, {
+			address: position.contract,
+			abi: MetaMorpho,
+			functionName: "totalAssets",
+			args: []
+		}, {
+			address: position.contract,
+			abi: MetaMorpho,
+			functionName: "totalSupply",
+			args: []
+		}, {
+			address: position.contract,
+			abi: MetaMorpho,
+			functionName: "asset",
+			args: []
+		});
+		contracts.set(position.contract.toLowerCase(), {
+			decimalsOffset: void 0,
+			totalAssets: void 0,
+			totalSupply: void 0,
+			asset: void 0
+		});
+	}
+	const results = await batchMulticall({
+		client,
+		calls,
+		blockNumber: BigInt(blockNumber),
+		batchSize: maxBatchSize,
+		retryAttempts,
+		retryDelayMs
+	});
+	const convertToAssetsList = [];
+	for (let i = 0; i < results.length; i++) {
+		const call = calls[i];
+		const value = results[i];
+		const contract = contracts.get(call.address.toLowerCase());
+		if (!contract) continue;
+		switch (call.functionName) {
+			case "balanceOf":
+				convertToAssetsList.push(() => call.convertToAssets(value));
+				break;
+			case "DECIMALS_OFFSET":
+				contract.decimalsOffset = value;
+				break;
+			case "totalAssets":
+				contract.totalAssets = value;
+				break;
+			case "totalSupply":
+				contract.totalSupply = value;
+				break;
+			case "asset":
+				contract.asset = value.toLowerCase();
+				break;
+		}
+	}
+	for (const convertToAssets of convertToAssetsList) convertToAssets();
+	return positions;
+}
+
+//#endregion
+//#region src/indexer/collectors/CollectFunctions/collectPositions.ts
+async function* collectPositions(parameters) {
+	let { db, collector, client, lastBlockNumber: blockNumber, epoch, options: { maxBatchSize = 1e3, retryAttempts = 5, retryDelayMs = 500, blockWindow } = {} } = parameters;
+	const logger = getLogger();
+	let startBlock = blockNumber;
+	let reorgDetected = false;
+	const TransferEvent = {
+		type: "event",
+		name: "Transfer",
+		inputs: [
+			{
+				name: "from",
+				type: "address",
+				indexed: true
+			},
+			{
+				name: "to",
+				type: "address",
+				indexed: true
+			},
+			{
+				name: "value",
+				type: "uint256",
+				indexed: false
+			}
+		]
+	};
+	const { blockNumber: latestBlockNumberChain } = await db.blocks.getChain(client.chain.id);
+	const stream = streamLogs({
+		client,
+		event: TransferEvent,
+		blockNumberGte: blockNumber,
+		blockNumberLte: latestBlockNumberChain,
+		order: "asc",
+		options: {
+			maxBatchSize,
+			blockWindow
+		}
+	});
+	for await (const { logs, blockNumber: lastStreamBlockNumber } of stream) {
+		blockNumber = lastStreamBlockNumber;
+		const parsedLogs = parseEventLogs({
+			abi: [TransferEvent],
+			logs
+		});
+		const transfers = [];
+		for (const log of parsedLogs) {
+			if (log.blockNumber === null || log.logIndex === null || log.transactionHash === null) {
+				logger.debug({
+					collector,
+					chainId: client.chain.id,
+					msg: "Skipping log because it is missing required fields"
+				});
+				continue;
+			}
+			transfers.push(from$8({
+				id: `${client.chain.id}-${log.blockNumber.toString()}-${log.transactionHash}-${log.logIndex.toString()}`,
+				chainId: client.chain.id,
+				contract: log.address,
+				from: log.args.from,
+				to: log.args.to,
+				value: log.args.value,
+				blockNumber: Number(log.blockNumber)
+			}));
+		}
+		const { positions } = await db.positions.get({
+			chainId: client.chain.id,
+			filled: false
+		});
+		const newPositions = [];
+		try {
+			newPositions.push(...(await _snapshot({
+				positions,
+				blockNumber: latestBlockNumberChain,
+				client,
+				maxBatchSize,
+				retryAttempts,
+				retryDelayMs
+			})).map((p) => ({
+				...p,
+				blockNumber: p.blockNumber + 1
+			})));
+		} catch (err) {
+			logger.error({
+				msg: "Failed to snapshot new empty positions",
+				collector,
+				chain_id: client.chain.id,
+				block_number: latestBlockNumberChain,
+				err
+			});
+			yield startBlock;
+			return;
+		}
+		try {
+			await db.transaction(async (dbTx) => {
+				const insertPositions = async () => {
+					if (newPositions.length === 0) return;
+					try {
+						const count = await dbTx.positions.upsert(newPositions);
+						logger.info({
+							msg: `New positions`,
+							collector,
+							count,
+							chain_id: client.chain.id,
+							block_number: latestBlockNumberChain
+						});
+					} catch (err) {
+						throw new InsertPositionsError(err);
+					}
+				};
+				const insertTransfers = async () => {
+					if (transfers.length === 0) return;
+					try {
+						const created = await dbTx.transfers.create(transfers);
+						logger.info({
+							msg: `New transfers`,
+							collector,
+							count: created,
+							chain_id: client.chain.id,
+							block_range: [startBlock, blockNumber]
+						});
+					} catch (err) {
+						throw new InsertTransfersError(err);
+					}
+				};
+				const saveBlockNumber = async () => {
+					try {
+						await dbTx.blocks.advanceCollector({
+							collectorName: collector,
+							chainId: client.chain.id,
+							blockNumber,
+							epoch
+						});
+					} catch (_) {
+						throw new ReorgError(blockNumber);
+					}
+				};
+				await insertPositions();
+				await insertTransfers();
+				await saveBlockNumber();
+			});
+		} catch (err) {
+			if (err instanceof ReorgError) {
+				logger.info({
+					msg: "Reorg detected, positions and transfers insertion aborted",
+					collector,
+					count: newPositions.length,
+					chain_id: client.chain.id,
+					block_number: blockNumber
+				});
+				reorgDetected = true;
+			}
+			if (err instanceof InsertPositionsError) {
+				logger.error({
+					msg: "Failed to insert positions",
+					collector,
+					count: newPositions.length,
+					chain_id: client.chain.id,
+					block_number: latestBlockNumberChain,
+					err
+				});
+				throw err.cause;
+			}
+			if (err instanceof InsertTransfersError) {
+				logger.error({
+					msg: "Failed to insert transfers",
+					collector,
+					count: transfers.length,
+					chain_id: client.chain.id,
+					block_number: blockNumber,
+					err
+				});
+				throw err.cause;
+			}
+		}
+		if (!reorgDetected) {
+			startBlock = blockNumber;
+			if (newPositions.length === 0 && transfers.length === 0 && lastStreamBlockNumber !== latestBlockNumberChain) continue;
+			yield blockNumber;
+			continue;
+		}
+		await db.transaction(async (dbTx) => {
+			try {
+				const ancestor = await dbTx.blocks.getCollector({
+					collectorName: collector,
+					chainId: client.chain.id
+				});
+				blockNumber = ancestor.blockNumber;
+				const emptied = await dbTx.positions.setEmptyAfter({
+					chainId: client.chain.id,
+					blockNumber: blockNumber + 1
+				});
+				logger.info({
+					msg: "Reorg detected, positions set to empty",
+					collector,
+					count: emptied,
+					chain_id: client.chain.id,
+					block_number_gte: blockNumber + 1
+				});
+				await dbTx.blocks.advanceCollector({
+					collectorName: collector,
+					chainId: client.chain.id,
+					blockNumber,
+					epoch: ancestor.epoch
+				});
+			} catch (err) {
+				const msg = "Failed to revert to ancestor block when handling reorg.";
+				logger.error({
+					collector,
+					chainId: client.chain.id,
+					msg,
+					err
+				});
+				throw new Error(msg);
+			}
+		});
+		return;
+	}
+}
+/**
+* @internal
+*
+* Snapshots positions and returns the new positions.
+* @param parameters - {@link _snapshot.Parameters}
+* @returns The new positions. {@link _snapshot.ReturnType}
+*/
+async function _snapshot(parameters) {
+	const { positions, blockNumber, client, maxBatchSize, retryAttempts, retryDelayMs } = parameters;
+	const vaultV1Positions = [];
+	const erc20Positions = [];
+	for (const position of positions) switch (position.type) {
+		case Type.VAULT_V1:
+			vaultV1Positions.push(position);
+			break;
+		case Type.ERC20:
+			erc20Positions.push(position);
+			break;
+		default: throw new Error("Invalid position type");
+	}
+	const promises = [snapshotVaultPositions({
+		client,
+		positions: vaultV1Positions,
+		blockNumber,
+		options: {
+			maxBatchSize,
+			retryAttempts,
+			retryDelayMs
+		}
+	}), snapshotERC20Positions({
+		client,
+		positions: erc20Positions,
+		blockNumber,
+		options: {
+			maxBatchSize,
+			retryAttempts,
+			retryDelayMs
+		}
+	})];
+	return (await Promise.all(promises)).flat();
+}
+var InsertPositionsError = class extends BaseError {
+	name = "InsertPositionsError";
+	constructor(err) {
+		super("Failed to insert positions", { cause: err });
+	}
+};
+var InsertTransfersError = class extends BaseError {
+	name = "InsertTransfersError";
+	constructor(err) {
+		super("Failed to insert transfers", { cause: err });
+	}
+};
+
+//#endregion
+//#region src/indexer/collectors/CollectFunctions/collectPrices.ts
+/**
+* Collects oracle prices from on-chain oracles and persists them.
+*
+* - Reads oracle definitions as {@link Oracle.Oracle}.
+* - Uses chain metadata from {@link Chain.Chain}.
+*
+* @param parameters - {@link collectPrices.Parameters} (extends {@link Collector.CollectParameters})
+* with a client supporting {@link PublicActions.multicall | multicall}.
+* @yields Latest processed block number after each successful update.
+*/
+async function* collectPrices(parameters) {
+	const { db, collector, client, options: { maxBatchSize = 5e3, retryAttempts = 5, retryDelayMs = 500 } = {} } = parameters;
+	const logger = getLogger();
+	let blockNumber = parameters.lastBlockNumber;
+	const [oracles, { blockNumber: latestBlockNumberChain, epoch }] = await Promise.all([db.oracles.get({ chainId: client.chain.id }), db.blocks.getChain(client.chain.id)]);
+	const updatedOracles = [];
+	try {
+		const pricesMap = await fetchOraclePrices({
+			client,
+			oracles: oracles.map((oracle) => oracle.address),
+			options: {
+				batchSize: maxBatchSize,
+				blockNumber: latestBlockNumberChain,
+				retryAttempts,
+				retryDelayMs
+			}
+		});
+		for (const oracle of oracles) {
+			const price = pricesMap.get(oracle.address);
+			if (price !== void 0) updatedOracles.push({
+				chainId: client.chain.id,
+				address: oracle.address,
+				price,
+				blockNumber: latestBlockNumberChain
+			});
+		}
+	} catch (err) {
+		logger.error({
+			msg: "Failed to fetch oracle prices",
+			collector,
+			chain_id: client.chain.id,
+			block_number: latestBlockNumberChain,
+			err
+		});
+		yield blockNumber;
+		return;
+	}
+	let reorgDetected = false;
+	try {
+		await db.transaction(async (dbTx) => {
+			if (updatedOracles.length > 0) {
+				await dbTx.oracles.upsert(updatedOracles);
+				logger.info({
+					msg: "Oracle prices updated",
+					collector,
+					count: updatedOracles.length,
+					chain_id: client.chain.id,
+					block_number: latestBlockNumberChain
+				});
+			}
+			try {
+				await dbTx.blocks.advanceCollector({
+					collectorName: collector,
+					chainId: client.chain.id,
+					blockNumber: latestBlockNumberChain,
+					epoch
+				});
+			} catch (_) {
+				throw new ReorgError(latestBlockNumberChain);
+			}
+			blockNumber = latestBlockNumberChain;
+		});
+	} catch (err) {
+		if (err instanceof ReorgError) {
+			logger.info({
+				msg: "Reorg detected, prices update aborted",
+				collector,
+				count: updatedOracles.length,
+				chain_id: client.chain.id,
+				block_number: latestBlockNumberChain
+			});
+			reorgDetected = true;
+		} else throw new Error("Failed to collect oracle prices", { cause: err });
+	}
+	if (!reorgDetected) {
+		yield blockNumber;
+		return;
+	}
+	await db.transaction(async (dbTx) => {
+		try {
+			const ancestor = await dbTx.blocks.getCollector({
+				collectorName: collector,
+				chainId: client.chain.id
+			});
+			blockNumber = ancestor.blockNumber;
+			await dbTx.blocks.advanceCollector({
+				collectorName: collector,
+				chainId: client.chain.id,
+				blockNumber,
+				epoch: ancestor.epoch
+			});
+		} catch (err) {
+			const msg = "Failed to revert to ancestor block when handling reorg.";
+			logger.error({
+				collector,
+				chainId: client.chain.id,
+				msg,
+				err
+			});
+			throw new Error(msg);
+		}
+	});
+	yield blockNumber;
+}
+
+//#endregion
+//#region src/indexer/collectors/CollectorBuilder.ts
+function createBuilder(parameters) {
+	const { client, db, gatekeeper, options: { maxBlockNumber, blockWindow, interval } = {} } = parameters;
+	const createCollector = (name, collect) => create$16({
+		name,
+		collect,
+		client,
+		db,
+		options: {
+			maxBlockNumber,
+			interval
+		}
+	});
+	return {
+		buildOffersCollector: ({ options: { maxBatchSize = 1e3 } = {} }) => {
+			return createCollector("offers", (p) => collectOffersV2({
+				...p,
+				gatekeeper,
+				collector: "offers",
+				client,
+				options: {
+					maxBatchSize,
+					blockWindow
+				}
+			}));
+		},
+		buildConsumedEventsCollector: ({ options: { maxBatchSize = 1e3 } = {} } = {}) => {
+			return createCollector("consumed_events", (p) => collectConsumedEvents({
+				...p,
+				collector: "consumed_events",
+				options: {
+					maxBatchSize,
+					blockWindow
+				}
+			}));
+		},
+		buildPricesCollector: ({ options: { maxBatchSize = 5e3, retryAttempts, retryDelayMs } = {} } = {}) => {
+			return createCollector("prices", (p) => collectPrices({
+				...p,
+				collector: "prices",
+				options: {
+					maxBatchSize,
+					retryAttempts,
+					retryDelayMs
+				}
+			}));
+		},
+		buildPositionsCollector: ({ options: { maxBatchSize = 1e3, retryAttempts, retryDelayMs } = {} } = {}) => {
+			return createCollector("positions", (p) => collectPositions({
+				...p,
+				collector: "positions",
+				options: {
+					maxBatchSize,
+					retryAttempts,
+					retryDelayMs,
+					blockWindow
+				}
+			}));
+		}
+	};
+}
+
+//#endregion
+//#region src/indexer/collectors/Collectors.ts
+const from$2 = (parameters) => {
+	const { client, db, gatekeeper, maxBatchSize, maxBlockNumber, blockWindow, interval, retryAttempts, retryDelayMs } = parameters;
+	const collectorBuilder = createBuilder({
+		client,
+		db,
+		gatekeeper,
+		options: {
+			maxBlockNumber,
+			blockWindow,
+			interval
+		}
+	});
+	return {
+		offersCollector: collectorBuilder.buildOffersCollector({ options: { maxBatchSize } }),
+		consumedEventsCollector: collectorBuilder.buildConsumedEventsCollector({ options: { maxBatchSize } }),
+		pricesCollector: collectorBuilder.buildPricesCollector({ options: {
+			maxBatchSize,
+			retryAttempts,
+			retryDelayMs
+		} }),
+		positionsCollector: collectorBuilder.buildPositionsCollector({ options: {
+			maxBatchSize,
+			retryAttempts,
+			retryDelayMs
+		} })
+	};
+};
+
+//#endregion
+//#region src/indexer/Indexer.ts
+function from$1(config) {
+	const { client, gatekeeper, db, interval = 1e4, maxBatchSize = 1e3, maxBlockNumber, blockWindow, retryAttempts, retryDelayMs } = config;
+	const { offersCollector, consumedEventsCollector, positionsCollector, pricesCollector } = from$2({
+		client,
+		db,
+		gatekeeper,
+		maxBatchSize,
+		maxBlockNumber,
+		blockWindow,
+		interval,
+		retryAttempts,
+		retryDelayMs
+	});
+	return create$18({
+		client,
+		collectors: [
+			offersCollector,
+			consumedEventsCollector,
+			positionsCollector,
+			pricesCollector
+		]
+	});
+}
+function create$18(params) {
+	const { collectors, client } = params;
+	const indexerId = `${client.chain.id.toString()}.indexer`;
+	const tracer = getTracer(`router.${indexerId}`);
+	const iterators = collectors.map((collector) => collector.collect());
+	const next = async () => {
+		await startActiveSpan(tracer, `${indexerId}.next`, async () => {
+			await Promise.all(iterators.map((iterator) => iterator.next()));
+		});
+	};
+	const _return = async () => {
+		await Promise.all(iterators.map(async (iterator) => iterator.return()));
+	};
+	return {
+		start: () => {
+			const stops = collectors.map((collector) => start(collector));
+			return () => {
+				stops.forEach((stop) => {
+					stop();
+				});
+			};
+		},
+		next,
+		return: _return
+	};
+}
+
+//#endregion
+//#region src/indexer/collectors/Admin.ts
+function create$17(parameters) {
+	const collector = "admin";
+	const { client, db, options: { maxBatchSize = 25, maxBlockNumber } = {} } = parameters;
+	const maxBlockNumberBI = maxBlockNumber !== void 0 ? BigInt(maxBlockNumber) : void 0;
+	let finalizedBlock = null;
+	let unfinalizedBlocks = [];
+	let initialized = false;
+	const logger = getLogger();
+	let isMaxBlockNumberReached = false;
+	let tick = 0;
+	return { syncBlock: async () => {
+		if (!initialized) {
+			await Promise.all(names.map((collectorName) => db.blocks.init({
+				chainId: client.chain.id,
+				collectorName
+			})));
+			initialized = true;
+		}
+		if (isMaxBlockNumberReached) return true;
+		const head = await client.getBlock({
+			blockTag: "latest",
+			includeTransactions: false
+		});
+		await db.transaction(async (dbTx) => {
+			const { epoch, blockNumber: latestSavedBlockNumber } = await dbTx.blocks.getChain(client.chain.id);
+			if (maxBlockNumberBI !== void 0 && head.number >= maxBlockNumberBI) {
+				logger.info({
+					msg: `Head is greater than max block number`,
+					collector,
+					chainId: client.chain.id,
+					block_number: head.number,
+					max_block_number: maxBlockNumber
+				});
+				await dbTx.blocks.handleReorg({
+					chainId: client.chain.id,
+					blockNumber: maxBlockNumber,
+					epoch: epoch + 1n
+				});
+				isMaxBlockNumberReached = true;
+				return isMaxBlockNumberReached;
+			}
+			finalizedBlock = await fetchFinalizedBlock({
+				tick,
+				client,
+				logger,
+				collector,
+				unfinalizedBlocks,
+				previousFinalizedBlock: finalizedBlock
+			});
+			tick++;
+			let { block: returnedBlock, didReorgHappened, unfinalizedBlocks: newUnfinalizedBlocks } = await reconcile({
+				client,
+				block: head,
+				unfinalizedBlocks,
+				finalizedBlock,
+				logger,
+				collector,
+				maxBatchSize
+			});
+			unfinalizedBlocks = newUnfinalizedBlocks;
+			const blockNumber = Number(returnedBlock.number);
+			didReorgHappened = didReorgHappened || blockNumber < latestSavedBlockNumber;
+			if (didReorgHappened) await dbTx.blocks.handleReorg({
+				chainId: client.chain.id,
+				blockNumber,
+				epoch: epoch + 1n
+			});
+			else await dbTx.blocks.advanceChain({
+				chainId: client.chain.id,
+				blockNumber,
+				epoch
+			});
+		});
+		return isMaxBlockNumberReached;
+	} };
+}
+const commonAncestor = (block, unfinalizedBlocks) => {
+	const parent = unfinalizedBlocks.find((b) => b.hash === block.parentHash);
+	if (parent) return parent;
+	return null;
+};
+const fetchFinalizedBlock = async (parameters) => {
+	let { tick, client, logger, collector, unfinalizedBlocks, previousFinalizedBlock } = parameters;
+	let finalizedBlock = previousFinalizedBlock;
+	if (tick % 20 === 0 || previousFinalizedBlock === null) {
+		finalizedBlock = await client.getBlock({
+			blockTag: "finalized",
+			includeTransactions: false
+		});
+		if (finalizedBlock === null || finalizedBlock.number === null) {
+			const msg = "Failed to get finalized block";
+			logger.fatal({
+				collector,
+				chainId: client.chain.id,
+				msg
+			});
+			throw new Error(msg);
+		}
+		unfinalizedBlocks = unfinalizedBlocks.filter((b) => b.number >= finalizedBlock.number);
+	}
+	if (finalizedBlock.number === null || finalizedBlock.hash === null || finalizedBlock.parentHash === null) {
+		const msg = "Failed to get finalized block";
+		logger.fatal({
+			collector,
+			chainId: client.chain.id,
+			msg
+		});
+		throw new Error(msg);
+	}
+	return {
+		hash: finalizedBlock.hash,
+		number: finalizedBlock.number,
+		parentHash: finalizedBlock.parentHash
+	};
+};
+const reconcile = async (parameters) => {
+	let { client, block, unfinalizedBlocks, finalizedBlock, logger, collector, maxBatchSize } = parameters;
+	const chain = client.chain;
+	if (block.hash === null || block.number === null || block.parentHash === null) throw new Error("Failed to get block");
+	const latestBlock = unfinalizedBlocks[unfinalizedBlocks.length - 1];
+	if (latestBlock === void 0) {
+		const newBlock = {
+			hash: block.hash,
+			number: block.number,
+			parentHash: block.parentHash
+		};
+		unfinalizedBlocks.push(newBlock);
+		return {
+			block: newBlock,
+			didReorgHappened: false,
+			unfinalizedBlocks
+		};
+	}
+	if (latestBlock.hash === block.hash) return {
+		block: latestBlock,
+		didReorgHappened: false,
+		unfinalizedBlocks
+	};
+	if (latestBlock.number >= block.number) {
+		const ancestor = commonAncestor(block, unfinalizedBlocks) || finalizedBlock;
+		logger.info({
+			msg: `Reorg detected, latestBlock.number >= block.number`,
+			collector,
+			chain_id: chain.id,
+			ancestor: ancestor.number,
+			latest_block_number: latestBlock.number,
+			block_number: block.number
+		});
+		unfinalizedBlocks = unfinalizedBlocks.filter((b) => b.number <= ancestor.number);
+		return {
+			block: ancestor,
+			didReorgHappened: true,
+			unfinalizedBlocks
+		};
+	}
+	if (latestBlock.number + 1n < block.number) {
+		logger.debug({
+			collector,
+			chain_id: chain.id,
+			block_range: [latestBlock.number, block.number],
+			msg: `Missing blocks`
+		});
+		const missingBlockNumbers = (() => {
+			const missingBlockNumbers = [];
+			let start = latestBlock.number + 1n;
+			const threshold = latestBlock.number + BigInt(maxBatchSize) > block.number ? block.number : latestBlock.number + BigInt(maxBatchSize);
+			while (start < threshold) {
+				missingBlockNumbers.push(start);
+				start = start + 1n;
+			}
+			return missingBlockNumbers;
+		})();
+		const missingBlocks = await Promise.all(missingBlockNumbers.map((blockNumber) => retry(async () => await client.getBlock({
+			blockNumber,
+			includeTransactions: false
+		}))));
+		for (const missingBlock of missingBlocks) {
+			const { block: returnedBlock, didReorgHappened, unfinalizedBlocks: newUnfinalizedBlocks } = await reconcile({
+				client,
+				block: missingBlock,
+				unfinalizedBlocks,
+				finalizedBlock,
+				logger,
+				collector,
+				maxBatchSize
+			});
+			if (returnedBlock.number !== missingBlock.number) return {
+				block: returnedBlock,
+				didReorgHappened,
+				unfinalizedBlocks: newUnfinalizedBlocks
+			};
+		}
+		return reconcile({
+			client,
+			block,
+			unfinalizedBlocks,
+			finalizedBlock,
+			logger,
+			collector,
+			maxBatchSize
+		});
+	}
+	if (block.parentHash !== latestBlock.hash) {
+		const ancestor = commonAncestor(block, unfinalizedBlocks) || finalizedBlock;
+		logger.info({
+			msg: `Reorg detected, block parent hash !== latest block hash`,
+			collector,
+			chain_id: chain.id,
+			ancestor: ancestor.number,
+			latest_block_number: latestBlock.number,
+			block_number: block.number
+		});
+		unfinalizedBlocks = unfinalizedBlocks.filter((b) => b.number <= ancestor.number);
+		return {
+			block: ancestor,
+			didReorgHappened: true,
+			unfinalizedBlocks
+		};
+	}
+	const newBlock = {
+		hash: block.hash,
+		number: block.number,
+		parentHash: block.parentHash
+	};
+	unfinalizedBlocks.push(newBlock);
+	return {
+		block: newBlock,
+		didReorgHappened: false,
+		unfinalizedBlocks
+	};
+};
+
+//#endregion
+//#region src/indexer/collectors/Collector.ts
+const names = [
+	"offers",
+	"consumed_events",
+	"positions",
+	"prices"
+];
+function create$16({ name, collect, client, db, options }) {
+	const admin = create$17({
+		client,
+		db,
+		options
+	});
+	return {
+		name,
+		chain: client.chain,
+		client,
+		db,
+		interval: options.interval ?? 1e4,
+		collect: async function* () {
+			const collector = name;
+			const chain = client.chain;
+			const logger = getLogger();
+			const collectorId = `${client.chain.id.toString()}.collector.${collector}`;
+			const tracer = getTracer(`router.${collectorId}`);
+			logger.info({
+				msg: `Collector started`,
+				collector,
+				chain_id: chain.id
+			});
+			let iterator = null;
+			let lastBlockNumber;
+			while (true) try {
+				if (iterator === null) iterator = await startActiveSpan(tracer, `${collectorId}.init`, async () => {
+					const { collector: collectorBlock } = await db.blocks.init({
+						collectorName: name,
+						chainId: chain.id
+					});
+					lastBlockNumber = collectorBlock.blockNumber;
+					return collect({
+						client,
+						collector: name,
+						epoch: collectorBlock.epoch,
+						lastBlockNumber,
+						db
+					});
+				});
+				if (await startActiveSpan(tracer, `${collectorId}.syncBlock`, async (span) => {
+					const isMaxBlockNumberReached = await admin.syncBlock();
+					span.setAttribute("collector.is_max_block_reached", isMaxBlockNumberReached);
+					return isMaxBlockNumberReached;
+				}) && options.maxBlockNumber !== void 0 && lastBlockNumber !== void 0 && options.maxBlockNumber === lastBlockNumber) return;
+				const { blockNumber, done } = await startActiveSpan(tracer, `${collectorId}.next`, async () => {
+					if (iterator === null) throw new Error("Iterator is not initialized");
+					const { value: blockNumber, done } = await iterator.next();
+					return {
+						blockNumber,
+						done
+					};
+				});
+				if (done) iterator = null;
+				else {
+					lastBlockNumber = blockNumber;
+					yield blockNumber;
+				}
+			} catch (err) {
+				const isError = err instanceof Error;
+				logger.error({
+					msg: "Collector error",
+					collector,
+					chain_id: chain.id,
+					error: isError ? err.message : String(err),
+					stack: isError ? err.stack : void 0
+				});
+			}
+		}
+	};
+}
+/** Start a collector with its own polling cadence based on chain head lag.
+* @param collector - The collector to start.
+* @returns A function to stop the collector.
+*/
+function start(collector) {
+	let stopped = false;
+	const it = collector.collect();
+	const logger = getLogger();
+	const collectorId = `${collector.chain.id.toString()}.collector.${collector.name}`;
+	const tracer = getTracer(`router.${collectorId}`);
+	const blocks = collector.db.blocks;
+	let initialized = false;
+	(async () => {
+		while (!stopped) try {
+			await startActiveSpan(tracer, `${collectorId}.poll`, async () => {
+				if (!initialized) {
+					await blocks.init({
+						chainId: collector.chain.id,
+						collectorName: collector.name
+					});
+					initialized = true;
+				}
+				const [block, { blockNumber: collectorBlockNumber }] = await Promise.all([collector.client.getBlock({
+					blockTag: "latest",
+					includeTransactions: false
+				}), blocks.getCollector({
+					collectorName: collector.name,
+					chainId: collector.chain.id
+				})]);
+				const delay = Number(block.number) > collectorBlockNumber + 10 ? 250 : collector.interval;
+				const waitSpan = tracer.startSpan(`${collectorId}.wait`);
+				try {
+					await wait(delay);
+				} finally {
+					waitSpan.end();
+				}
+				await it.next();
+			});
+		} catch (err) {
+			const error = err instanceof Error ? err : new Error(String(err));
+			logger.error({
+				msg: "Collector polling error",
+				collector: collector.name,
+				chain_id: collector.chain.id,
+				err: error
+			});
+		}
+		await it.return();
+	})();
+	return () => {
+		stopped = true;
+	};
+}
+
 //#endregion
 //#region src/database/domains/Blocks.ts
 /** Postgres implementation. */
@@ -7705,35 +7630,15 @@ async function _getOffers(db, params) {
         AND LOWER(pc.contract) = LOWER(c.position_contract)
         AND LOWER(pc."user") = LOWER(c.position_user)
     ),
-    -- Compute contribution per callback in loan terms (with oracle price via LEFT JOIN)
+    -- Compute contribution per callback in loan terms (loan token only — collateral positions are not indexed)
     callback_loan_contribution AS (
       SELECT
         cc.*,
         CASE
-          -- No lot exists: contribution is 0
           WHEN cc.lot_lower IS NULL THEN 0
-          -- Loan token position: use lot_balance directly, apply callback limit
-          WHEN LOWER(cc.position_asset) = LOWER(cc.loan_token) THEN
-            LEAST(
-              cc.lot_balance,
-              COALESCE(cc.callback_amount::numeric, cc.lot_balance)
-            )
-          -- Collateral position: convert to loan using (amount * price / 10^36) * lltv / 10^18
-          ELSE
-            (
-              LEAST(
-                cc.lot_balance,
-                COALESCE(cc.callback_amount::numeric, cc.lot_balance)
-              ) * COALESCE(collat_oracle.price::numeric, 0) / 1e36
-            ) * COALESCE(collat_info.lltv::numeric, 0) / 1e18
+          ELSE LEAST(cc.lot_balance, COALESCE(cc.callback_amount::numeric, cc.lot_balance))
         END AS contribution_in_loan
       FROM callback_contributions cc
-      LEFT JOIN ${obligationCollateralsV2} collat_info
-        ON collat_info.obligation_id = cc.obligation_id
-        AND LOWER(collat_info.asset) = LOWER(cc.position_asset)
-      LEFT JOIN ${oracles} collat_oracle
-        ON collat_oracle.chain_id = collat_info.oracle_chain_id
-        AND LOWER(collat_oracle.address) = LOWER(collat_info.oracle_address)
     ),
     -- Aggregate contributions per offer, deduplicating by position using DISTINCT ON
     offer_contributions AS (
@@ -7770,6 +7675,22 @@ async function _getOffers(db, params) {
       GROUP BY hash, obligation_id, assets, price, 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.obligation_units, p.obligation_shares,
+        p.maturity, p.expiry, p.start, p.group_group,
+        p.buy, p.callback_address, p.callback_data,
+        p.block_number, p.group_chain_id, p.group_maker,
+        p.consumed, p.chain_id, p.loan_token, p.session,
+        0 AS total_available
+      FROM paged p
+      WHERE p.buy = false
+        AND NOT EXISTS (
+          SELECT 1 FROM ${offersCallbacks} oc2
+          WHERE oc2.offer_hash = p.hash
+        )
     )
     -- Final SELECT with inline takeable computation
     SELECT
@@ -7792,18 +7713,24 @@ async function _getOffers(db, params) {
       oc.block_number,
       oc.session,
       COALESCE(oc.total_available, 0) AS available,
-      -- takeable = min(assets - consumed, total_available)
-      GREATEST(0, LEAST(
-        oc.assets::numeric - oc.consumed::numeric,
-        COALESCE(oc.total_available, 0)
-      )) AS takeable,
+      -- takeable: sell offers use assets - consumed directly (collateral positions not indexed yet)
+      CASE WHEN oc.buy = false
+        THEN GREATEST(0, oc.assets::numeric - oc.consumed::numeric)
+        ELSE GREATEST(0, LEAST(
+          oc.assets::numeric - oc.consumed::numeric,
+          COALESCE(oc.total_available, 0)
+        ))
+      END AS takeable,
       c.collaterals
     FROM offer_contributions oc
     LEFT JOIN collats c ON c.obligation_id = oc.obligation_id
-    WHERE GREATEST(0, LEAST(
-      oc.assets::numeric - oc.consumed::numeric,
-      COALESCE(oc.total_available, 0)
-    )) > 0
+    WHERE CASE WHEN oc.buy = false
+      THEN GREATEST(0, oc.assets::numeric - oc.consumed::numeric)
+      ELSE GREATEST(0, LEAST(
+        oc.assets::numeric - oc.consumed::numeric,
+        COALESCE(oc.total_available, 0)
+      ))
+    END > 0
     ORDER BY
       oc.price::numeric ${priceSortDirection === "asc" ? sql`ASC` : sql`DESC`},
       oc.block_number ASC,
@@ -9682,12 +9609,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_price: firstLevel?.price.toString() ?? null,
+			first_level_assets: firstLevel?.assets.toString() ?? null,
+			first_level_count: firstLevel?.count ?? null
+		});
 		return success({
 			data: levels.map(from$6),
 			cursor: nextCursor
@@ -10177,6 +10126,7 @@ async function getOffersQuery(db, parameters) {
 	if (cursor !== null && cursor !== void 0) {
 		if (!cursor.startsWith("0x") || cursor.length !== 66) throw new Error("Invalid cursor format");
 	}
+	const now = Math.floor((Date.now() - 1) / 1e3);
 	const collateralsLateral = db.select({ collaterals: sql`COALESCE(
         jsonb_agg(
           jsonb_build_object(
@@ -10188,29 +10138,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
-              -- If asset is null, position available is 0
-              WHEN ${positions.asset} IS NULL THEN 0
-
-              -- Position asset matches loan token: no conversion needed
-              WHEN ${positions.asset} = ${obligations.loanToken} THEN
-                CASE
-                  WHEN ${callbacks.amount} IS NULL THEN COALESCE(${positions.balance}, 0)::numeric
-                  ELSE LEAST(${callbacks.amount}::numeric, COALESCE(${positions.balance}, 0)::numeric)
-                END
-
-              -- Position asset is collateral: apply oracle price * lltv
-              -- Formula: balance * price / 1e36 * lltv / 1e18
-              ELSE
-                (CASE
-                  WHEN ${callbacks.amount} IS NULL THEN COALESCE(${positions.balance}, 0)::numeric
-                  ELSE LEAST(${callbacks.amount}::numeric, COALESCE(${positions.balance}, 0)::numeric)
-                END)
-                * COALESCE(${oracles.price}, 0)::numeric / 1e36
-                * COALESCE(${obligationCollateralsV2.lltv}, 0)::numeric / 1e18
-            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))).leftJoin(obligationCollateralsV2, and(eq(obligationCollateralsV2.obligationId, offers.obligationId), eq(obligationCollateralsV2.asset, positions.asset))).leftJoin(oracles, and(eq(oracles.chainId, obligationCollateralsV2.oracleChainId), eq(oracles.address, obligationCollateralsV2.oracleAddress))).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,
@@ -10231,18 +10209,25 @@ async function getOffersQuery(db, parameters) {
 		callbackData: offers.callbackData,
 		collaterals: collateralsLateral.collaterals,
 		blockNumber: offers.blockNumber,
-		available: sql`COALESCE(${availableLateral.available}::numeric, 0)`.as("available"),
-		takeable: sql`FLOOR(GREATEST(
-            0,
-            LEAST(
-              ${offers.assets}::numeric - ${groups.consumed}::numeric,
-              COALESCE(${availableLateral.available}::numeric, 0)
-            )
+		available: sql`${availableExpr}::numeric`.as("available"),
+		takeable: sql`FLOOR(GREATEST(0,
+            CASE WHEN ${offers.buy} = false
+              THEN ${offers.assets}::numeric - ${groups.consumed}::numeric
+              ELSE LEAST(
+                ${offers.assets}::numeric - ${groups.consumed}::numeric,
+                ${availableExpr}::numeric
+              )
+            END
           ))`.as("takeable")
-	}).from(offers).innerJoin(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, maker === void 0 ? sql`GREATEST(0, LEAST(
-                  ${offers.assets}::numeric - ${groups.consumed}::numeric,
-                  COALESCE(${availableLateral.available}::numeric, 0)
-                )) > 0` : void 0)).orderBy(asc(offers.hash)).limit(limit)).map((row) => {
+	}).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,
+                      ${availableExpr}::numeric
+                    )
+                  END
+                ) > 0` : void 0)).orderBy(asc(offers.hash)).limit(limit)).map((row) => {
 		return {
 			hash: row.hash,
 			maker: row.maker,
@@ -10352,35 +10337,6 @@ async function getUserPositions(queryParameters, db) {
 	}
 }
 
-//#endregion
-//#region src/api/Controllers/resolveCallbackTypes.ts
-/**
-* Resolve callback types for a list of callback addresses grouped by chain.
-* @param body - Request body with callback addresses. {@link CallbackTypesRequest}
-* @param chains - Chains to resolve callback types against. {@link Chain.Chain}
-* @returns Callback types grouped by chain. {@link CallbackTypesPayload}
-*/
-async function resolveCallbackTypes$1(body, chains) {
-	const result = safeParse("callback_types", body, (issue) => issue.message);
-	if (!result.success) return failure(result.error);
-	const request = result.data;
-	const chainIds = new Set(chains.map((chain) => chain.id));
-	const unknown = request.callbacks.find((entry) => !chainIds.has(entry.chain_id));
-	if (unknown) return failure(new BadRequestError(`Unknown chain id ${unknown.chain_id}`));
-	try {
-		const data = resolveCallbackTypes$2({
-			chains,
-			request
-		});
-		return success({
-			data,
-			cursor: null
-		});
-	} catch (err) {
-		return failure(err);
-	}
-}
-
 //#endregion
 //#region src/api/Api.ts
 function from(config) {
@@ -10450,24 +10406,9 @@ function serve$1(parameters) {
 			const { statusCode, body } = await gatekeeper.validate(reqBody);
 			return c.json(body, statusCode);
 		} catch (err) {
-			const failure$1 = failure(err);
-			return c.json(failure$1.body, failure$1.statusCode);
-		}
-	});
-	app.post("/v1/callbacks", async (c) => {
-		let body;
-		try {
-			body = await c.req.json();
-		} catch (err) {
-			const failure$3 = failure(err);
-			return c.json(failure$3.body, failure$3.statusCode);
-		}
-		if (body === null || typeof body !== "object") {
-			const failure$2 = failure(new BadRequestError("Request body must be a JSON object"));
+			const failure$2 = failure(err);
 			return c.json(failure$2.body, failure$2.statusCode);
 		}
-		const { statusCode, body: responseBody } = await resolveCallbackTypes$1(body, chainRegistry.list());
-		return c.json(responseBody, statusCode);
 	});
 	app.get("/v1/users/:userAddress/positions", async (c) => {
 		const query = c.req.query();
@@ -10499,8 +10440,8 @@ function serve$1(parameters) {
 			const { statusCode, body } = await gatekeeper.getConfigRules(c.req.query());
 			return c.json(body, statusCode);
 		} catch (err) {
-			const failure$4 = failure(err);
-			return c.json(failure$4.body, failure$4.statusCode);
+			const failure$1 = failure(err);
+			return c.json(failure$1.body, failure$1.statusCode);
 		}
 	});
 	app.get("/docs/openapi", async (c) => c.text(JSON.stringify(await getSwaggerJson()), 200, { "Content-Type": "application/json; charset=utf-8" }));
@@ -10591,23 +10532,11 @@ function createHttpClient(config) {
 			issues: []
 		};
 	};
-	const getCallbackTypes = async (requestPayload) => {
-		const response = await request("/v1/callbacks", {
-			method: "POST",
-			headers: { "content-type": "application/json" },
-			body: JSON.stringify(requestPayload)
-		});
-		const json = await response.json();
-		if (!response.ok) throw new Error(`Gatekeeper callbacks request failed: ${extractErrorMessage(json) ?? response.statusText}`);
-		if (!("data" in json) || !Array.isArray(json.data)) throw new Error("Gatekeeper callbacks response is invalid.");
-		return json.data;
-	};
 	return {
 		baseUrl,
 		validate,
 		getConfigRules,
-		isAllowed,
-		getCallbackTypes
+		isAllowed
 	};
 }
 function mergeHeaders(base, extra) {
@@ -10843,35 +10772,17 @@ function createMockOffers(parameters) {
 			lltv
 		}));
 		if (!chainRegistry.getById(offer.chainId)) throw new Error(`Missing chain config for id ${offer.chainId}`);
-		const callbackType = buy ? Type$1.BuyVaultV1Callback : Type$1.SellERC20Callback;
-		const callbackAddress = buy ? BUY_CALLBACK_ADDRESS : SELL_CALLBACK_ADDRESS;
-		const callbackData = buildMockCallbackData(callbackType, {
-			...offer,
-			collaterals
-		});
 		return from$12({
 			...offer,
 			loanToken,
 			collaterals,
 			callback: {
-				address: callbackAddress,
-				data: callbackData
+				address: zeroAddress,
+				data: "0x"
 			}
 		});
 	});
 }
-function buildMockCallbackData(callbackType, offer) {
-	const assets = offer.collaterals.map((collateral) => collateral.asset);
-	const amounts = offer.collaterals.map(() => offer.assets);
-	if (callbackType === Type$1.BuyVaultV1Callback) return encodeBuyVaultV1Callback({
-		vaults: assets,
-		amounts
-	});
-	return encodeSellERC20Callback({
-		collaterals: assets,
-		amounts
-	});
-}
 function seedMockOracles(offers, price, blockNumber) {
 	const oracleMap = /* @__PURE__ */ new Map();
 	for (const offer of offers) for (const collateral of offer.collaterals) {
@@ -10886,8 +10797,6 @@ function seedMockOracles(offers, price, blockNumber) {
 	}
 	return Array.from(oracleMap.values());
 }
-const BUY_CALLBACK_ADDRESS = "0x3333333333333333333333333333333333333333";
-const SELL_CALLBACK_ADDRESS = "0x1111111111111111111111111111111111111111";
 async function seedOffers(parameters) {
 	const { db, offers, blockNumber } = parameters;
 	if (offers.length === 0) return;
@@ -10904,14 +10813,10 @@ async function seedOffers(parameters) {
 	}]);
 }
 async function seedOfferAssociations(parameters) {
-	const { db, gatekeeper, offers, blockNumber } = parameters;
+	const { db, offers, blockNumber } = parameters;
 	if (offers.length === 0) return;
 	const { callbacks, positions, lots } = buildOfferAssociationsFromOffers({
 		offers,
-		callbackTypes: await resolveCallbackTypes({
-			gatekeeper,
-			offers
-		}),
 		blockNumber
 	});
 	if (positions.length > 0) await db.positions.upsert(positions);
@@ -10954,83 +10859,40 @@ function buildOfferDependencies(parameters) {
 		groups: Array.from(groupsByKey.values())
 	};
 }
-async function resolveCallbackTypes(parameters) {
-	const { gatekeeper, offers } = parameters;
-	const addressesByChain = /* @__PURE__ */ new Map();
-	for (const offer of offers) {
-		if (offer.callback.data === "0x") continue;
-		const set = addressesByChain.get(offer.chainId) ?? /* @__PURE__ */ new Set();
-		set.add(offer.callback.address.toLowerCase());
-		addressesByChain.set(offer.chainId, set);
-	}
-	if (addressesByChain.size === 0) return /* @__PURE__ */ new Map();
-	const request = { callbacks: Array.from(addressesByChain.entries()).map(([chainId, addresses]) => ({
-		chain_id: chainId,
-		addresses: Array.from(addresses)
-	})) };
-	const response = await gatekeeper.getCallbackTypes(request);
-	const typeByAddress = /* @__PURE__ */ new Map();
-	for (const entry of response) {
-		const chainId = entry.chain_id;
-		for (const [key, list] of Object.entries(entry)) {
-			if (key === "chain_id" || key === "not_supported") continue;
-			if (!Array.isArray(list)) continue;
-			for (const address of list) {
-				const mapKey = `${chainId}-${address.toLowerCase()}`;
-				typeByAddress.set(mapKey, key);
-			}
-		}
-	}
-	return typeByAddress;
-}
 function buildOfferAssociationsFromOffers(parameters) {
-	const { offers, callbackTypes, blockNumber } = parameters;
+	const { offers, blockNumber } = parameters;
 	const callbacks = [];
 	const positions = [];
 	const lots = [];
 	for (const offer of offers) {
-		if (offer.callback.data === "0x") continue;
-		const key = `${offer.chainId}-${offer.callback.address.toLowerCase()}`;
-		const callbackType = callbackTypes.get(key);
-		if (!callbackType) continue;
-		let decoded;
-		try {
-			decoded = decode$1(callbackType, offer.callback.data);
-		} catch (err) {
-			const error = err instanceof Error ? err : new Error(String(err));
-			throw new Error("Failed to decode callback data", { cause: error });
-		}
-		if (decoded.length === 0) continue;
+		if (!offer.buy) continue;
+		const loanToken = offer.loanToken.toLowerCase();
+		const offerHash = hash(offer);
+		positions.push(from$10({
+			chainId: offer.chainId,
+			contract: loanToken,
+			user: offer.maker,
+			type: Type.ERC20,
+			asset: loanToken,
+			balance: offer.assets,
+			blockNumber
+		}));
 		callbacks.push({
-			offerHash: hash(offer),
-			callbacks: decoded.map((callback) => ({
+			offerHash,
+			callbacks: [{
 				chainId: offer.chainId,
-				contract: callback.contract,
+				contract: loanToken,
 				user: offer.maker,
-				amount: callback.amount
-			}))
+				amount: offer.assets
+			}]
+		});
+		lots.push({
+			positionChainId: offer.chainId,
+			positionContract: loanToken,
+			positionUser: offer.maker,
+			group: offer.group,
+			size: offer.assets
 		});
-		for (const callback of decoded) {
-			const positionType = callbackType === Type$1.BuyVaultV1Callback ? Type.VAULT_V1 : Type.ERC20;
-			const positionAsset = callbackType === Type$1.BuyVaultV1Callback ? offer.loanToken : callback.contract;
-			positions.push(from$10({
-				chainId: offer.chainId,
-				contract: callback.contract,
-				user: offer.maker,
-				type: positionType,
-				balance: callback.amount * 2n,
-				asset: positionAsset,
-				blockNumber
-			}));
-			const isLoanPosition = positionAsset.toLowerCase() === offer.loanToken.toLowerCase();
-			lots.push({
-				positionChainId: offer.chainId,
-				positionContract: callback.contract,
-				positionUser: offer.maker,
-				group: offer.group,
-				size: isLoanPosition ? offer.assets : callback.amount
-			});
-		}
 	}
 	return {
 		callbacks,