@morpho-dev/router 0.7.0 → 0.7.1

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.1";
 var description = "Router package for Morpho protocol";
 
 //#endregion
@@ -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]
 	}
 };
@@ -2300,7 +2173,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 +2200,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 +2222,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 +2376,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 +2889,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 +2957,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 +2975,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",
@@ -3367,8 +3299,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 +3352,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 +3424,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 +3941,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 +3960,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 +4109,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 +4122,6 @@ const configRulesOracleExample = {
 const configRulesChecksumExample = "f1d2d2f924e986ac86fdf7b36c94bcdf";
 const configRulesPayloadExample = [
 	configRulesMaturityExample,
-	configRulesCallbackExample,
 	configRulesLoanTokenExample,
 	configRulesOracleExample
 ];
@@ -4347,14 +4186,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 +4249,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 +4428,7 @@ const OpenApi = async () => {
 			ObligationsController,
 			HealthController,
 			UsersController,
-			ValidateController,
-			CallbacksController
+			ValidateController
 		],
 		document: {
 			openapi: "3.1.0",
@@ -4851,16 +4684,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 +4702,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 +4957,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 +4964,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 +4972,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 +4986,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 +5081,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 +5484,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 +7563,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 +7608,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 +7646,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,
@@ -10177,6 +10037,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(
@@ -10190,27 +10051,14 @@ async function getOffersQuery(db, parameters) {
              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
+              ELSE
                 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");
+          ), 0)`.as("available") }).from(offersCallbacks).innerJoin(callbacks, eq(offersCallbacks.callbackId, callbacks.id)).innerJoin(positions, and(eq(callbacks.positionChainId, positions.chainId), eq(callbacks.positionContract, positions.contract), eq(callbacks.positionUser, positions.user))).where(eq(offersCallbacks.offerHash, offers.hash)).as("available_lateral");
 	const rows = (await db.select({
 		hash: offers.hash,
 		maker: offers.groupMaker,
@@ -10232,17 +10080,24 @@ async function getOffersQuery(db, parameters) {
 		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)
-            )
+		takeable: sql`FLOOR(GREATEST(0,
+            CASE WHEN ${offers.buy} = false
+              THEN ${offers.assets}::numeric - ${groups.consumed}::numeric
+              ELSE LEAST(
+                ${offers.assets}::numeric - ${groups.consumed}::numeric,
+                COALESCE(${availableLateral.available}::numeric, 0)
+              )
+            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`).leftJoinLateral(availableLateral, sql`true`).where(and(cursor !== null && cursor !== void 0 ? gt(offers.hash, cursor) : void 0, maker !== void 0 ? eq(offers.groupMaker, maker.toLowerCase()) : void 0, gte(offers.expiry, now), gte(offers.maturity, now), maker === void 0 ? sql`GREATEST(0,
+                  CASE WHEN ${offers.buy} = false
+                    THEN ${offers.assets}::numeric - ${groups.consumed}::numeric
+                    ELSE LEAST(
+                      ${offers.assets}::numeric - ${groups.consumed}::numeric,
+                      COALESCE(${availableLateral.available}::numeric, 0)
+                    )
+                  END
+                ) > 0` : void 0)).orderBy(asc(offers.hash)).limit(limit)).map((row) => {
 		return {
 			hash: row.hash,
 			maker: row.maker,
@@ -10352,35 +10207,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 +10276,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 +10310,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 +10402,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 +10642,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 +10667,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 +10683,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 +10729,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,