@morpho-dev/router 0.9.0 → 0.10.0

package/dist/cli.js

@@ -16,7 +16,7 @@ import os from "node:os";
 import path, { dirname, resolve } from "node:path";
 import { fileURLToPath } from "node:url";
 import { mkdir, readFile, rm, writeFile } from "node:fs/promises";
-import { bytesToHex, createPublicClient, createWalletClient, decodeAbiParameters, encodeAbiParameters, erc20Abi, getAddress, hashTypedData, hexToBytes, http, isAddress, isHex, keccak256, maxUint256, numberToHex, pad, parseAbi, parseEventLogs, publicActions, recoverAddress, stringify, toHex, zeroAddress } from "viem";
+import { bytesToHex, concatHex, createPublicClient, createWalletClient, decodeAbiParameters, encodeAbiParameters, erc20Abi, getAddress, hashTypedData, hexToBytes, http, isAddress, isHex, keccak256, maxUint256, numberToHex, pad, parseAbi, parseEventLogs, publicActions, recoverAddress, stringify, toHex, zeroAddress } from "viem";
 import { mnemonicToAccount, privateKeyToAccount } from "viem/accounts";
 import { getBlock, getBlockNumber, getLogs, multicall } from "viem/actions";
 import { anvil, base, mainnet } from "viem/chains";
@@ -39,7 +39,7 @@ import { migrate } from "drizzle-orm/node-postgres/migrator";
 import { drizzle as drizzle$1 } from "drizzle-orm/pglite";
 import { migrate as migrate$1 } from "drizzle-orm/pglite/migrator";
 import { Pool } from "pg";
-import { and, asc, desc, eq, gt, gte, inArray, lte, ne, sql } from "drizzle-orm";
+import { and, asc, desc, eq, gt, gte, inArray, lte, ne, or, sql } from "drizzle-orm";
 import { bigint, boolean, foreignKey, index, integer, numeric, pgSchema, primaryKey, serial, text, timestamp, uniqueIndex, varchar } from "drizzle-orm/pg-core";
 import { parse } from "smol-toml";
 import { cors } from "hono/cors";
@@ -152,7 +152,7 @@ function startActiveSpan(tracer, name, fn) {
 //#endregion
 //#region package.json
 var name = "@morpho-dev/router";
-var version = "0.9.0";
+var version = "0.10.0";
 var description = "Router package for Morpho protocol";
 
 //#endregion
@@ -264,7 +264,7 @@ const ChainId = {
 const chainNames = Object.keys(ChainId).map((key) => key.toLowerCase());
 const chainIds = Object.values(ChainId);
 const chainNameLookup = new Map(Object.entries(ChainId).map(([key, value]) => [value, key.toLowerCase()]));
-const chains$2 = {
+const chains$1 = {
 	ethereum: {
 		...mainnet,
 		id: ChainId.ETHEREUM,
@@ -301,16 +301,16 @@ const chains$2 = {
 		name: "base",
 		custom: {
 			morpho: {
-				address: "0x0000000000000000000000000000000000000000",
-				blockCreated: 0
+				address: "0x3F067BC9D8898F6ec02D6480c3fF1026E512BcBF",
+				blockCreated: 41799989
 			},
 			morphoBlue: {
 				address: "0xBBBBBbbBBb9cC5e90e3b3Af64bdAF62C37EEFFCb",
 				blockCreated: 0
 			},
 			mempool: {
-				address: "0x0000000000000000000000000000000000000000",
-				blockCreated: 35449942
+				address: "0xd25c7512EA5035bef4F18c708C0862E1B6151765",
+				blockCreated: 41800226
 			},
 			vaults: { factories: {
 				v1_0: {
@@ -513,7 +513,7 @@ async function deployContracts(parameters) {
 	const deployClient = client ?? createWalletClient({
 		account,
 		chain: {
-			...chains$2.anvil,
+			...chains$1.anvil,
 			id: chainId
 		},
 		transport: http(rpcUrl)
@@ -1081,7 +1081,7 @@ async function readLogs(parameters) {
 	return readFile(logPath, "utf8");
 }
 async function resolveForkContracts(parameters) {
-	const chain = parameters.forkChain ? chains$2[parameters.forkChain] : void 0;
+	const chain = parameters.forkChain ? chains$1[parameters.forkChain] : void 0;
 	const mempoolAddress = parameters.mempoolAddress ?? chain?.custom.mempool.address;
 	const morphoAddress = parameters.morphoAddress ?? chain?.custom.morpho.address;
 	const multicall3Address = parameters.multicall3Address ?? chain?.contracts?.multicall3?.address;
@@ -1112,8 +1112,8 @@ async function resolveForkContracts(parameters) {
 }
 async function validateForkContracts(parameters) {
 	const client = createPublicClient({
-		chain: parameters.forkChain ? chains$2[parameters.forkChain] : {
-			...chains$2.anvil,
+		chain: parameters.forkChain ? chains$1[parameters.forkChain] : {
+			...chains$1.anvil,
 			id: parameters.chainId
 		},
 		transport: http(parameters.rpcUrl)
@@ -1470,11 +1470,12 @@ async function run(parameters) {
 * @returns Gatekeeper instance. {@link Gatekeeper}
 */
 function create$21(parameters) {
-	const { rules } = parameters;
-	return { isAllowed: async (offers) => {
+	const { rules: rulesFactory } = parameters;
+	return { isAllowed: async (parameters) => {
+		const { offers, chainId } = parameters;
 		return await run({
 			items: offers,
-			rules
+			rules: rulesFactory(chainId)
 		});
 	} };
 }
@@ -1918,6 +1919,20 @@ const LLTVSchema = z$2.bigint({ coerce: true }).refine((lltv) => {
 
 //#endregion
 //#region src/core/Collateral.ts
+const abi$1 = [
+	{
+		type: "address",
+		name: "token"
+	},
+	{
+		type: "uint256",
+		name: "lltv"
+	},
+	{
+		type: "address",
+		name: "oracle"
+	}
+];
 const CollateralSchema = z$2.object({
 	asset: z$2.string().transform(transformAddress),
 	oracle: z$2.string().transform(transformAddress),
@@ -2028,11 +2043,29 @@ function stringifyBigint(value) {
 //#endregion
 //#region src/core/Obligation.ts
 const ObligationSchema = z$2.object({
-	chainId: z$2.number().min(0).max(Number.MAX_SAFE_INTEGER),
 	loanToken: z$2.string().transform(transformAddress),
 	collaterals: CollateralsSchema,
 	maturity: MaturitySchema
 });
+const abi = [
+	{
+		type: "address",
+		name: "loanToken"
+	},
+	{
+		type: "tuple[]",
+		name: "collaterals",
+		components: abi$1
+	},
+	{
+		type: "uint256",
+		name: "maturity"
+	}
+];
+const tupleAbi = [{
+	type: "tuple",
+	components: abi
+}];
 /**
 * Creates an obligation from the given parameters.
 * @constructor
@@ -2043,7 +2076,6 @@ const ObligationSchema = z$2.object({
 * @example
 * ```ts
 * const obligation = Obligation.from({
-*   chainId: 1,
 *   loanToken: privateKeyToAccount(generatePrivateKey()).address,
 *   collaterals: [
 *     Collateral.from({
@@ -2063,7 +2095,6 @@ function from$13(parameters) {
 			maturity: from$16(parameters.maturity)
 		});
 		return {
-			chainId: parsedObligation.chainId,
 			loanToken: parsedObligation.loanToken.toLowerCase(),
 			collaterals: parsedObligation.collaterals.sort((a, b) => a.asset.localeCompare(b.asset)),
 			maturity: parsedObligation.maturity
@@ -2073,49 +2104,27 @@ function from$13(parameters) {
 	}
 }
 /**
-* Calculates the obligation id based on the smart contract's Obligation struct.
-* The id is computed as keccak256(abi.encode(chainId, loanToken, collaterals, maturity)).
+* Calculates a canonical key for an obligation payload.
+* The key is computed as keccak256(abi.encode(loanToken, collaterals, maturity)).
 * @throws If the collaterals are not sorted alphabetically by address. {@link CollateralsAreNotSortedError}
-* @param parameters - {@link id.Parameters}
-* @returns The obligation id as a 32-byte hex string. {@link id.ReturnType}
+* @param parameters - {@link key.Parameters}
+* @returns The obligation key as a 32-byte hex string. {@link key.ReturnType}
 *
 * @example
 * ```ts
 * const obligation = Obligation.random();
-* const id = Obligation.id(obligation);
-* console.log(id); // 0x1234567890123456789012345678901234567890123456789012345678901234
+* const key = Obligation.key(obligation);
+* console.log(key); // 0x1234567890123456789012345678901234567890123456789012345678901234
 * ```
 */
-function id(parameters) {
+function key(parameters) {
 	let lastAsset = "";
 	for (const collateral of parameters.collaterals) {
 		const newAsset = collateral.asset.toLowerCase();
 		if (newAsset.localeCompare(lastAsset) < 0) throw new CollateralsAreNotSortedError();
 		lastAsset = newAsset;
 	}
-	return keccak256(encodeAbiParameters([
-		{ type: "uint256" },
-		{ type: "address" },
-		{
-			type: "tuple[]",
-			components: [
-				{
-					type: "address",
-					name: "token"
-				},
-				{
-					type: "uint256",
-					name: "lltv"
-				},
-				{
-					type: "address",
-					name: "oracle"
-				}
-			]
-		},
-		{ type: "uint256" }
-	], [
-		BigInt(parameters.chainId),
+	return keccak256(encodeAbiParameters(abi, [
 		parameters.loanToken.toLowerCase(),
 		parameters.collaterals.map((c) => ({
 			token: c.asset.toLowerCase(),
@@ -2138,6 +2147,43 @@ var CollateralsAreNotSortedError = class extends BaseError {
 	}
 };
 
+//#endregion
+//#region src/core/Id.ts
+const CREATION_CODE_PREFIX = "0x603f380380603f5f395ff3";
+/**
+* Builds the same creation code as `IdLib.creationCode` in Solidity.
+*
+* Layout: `prefix (11 bytes) + chainId (32 bytes) + morphoV2 (20 bytes) + abi.encode(obligation)`.
+*
+* @param parameters - {@link creationCode.Parameters}
+* @returns The CREATE2 init code bytes. {@link creationCode.ReturnType}
+*/
+function creationCode(parameters) {
+	const encodedObligation = encodeAbiParameters(tupleAbi, [{
+		loanToken: parameters.obligation.loanToken.toLowerCase(),
+		collaterals: parameters.obligation.collaterals.map((collateral) => ({
+			token: collateral.asset.toLowerCase(),
+			lltv: collateral.lltv,
+			oracle: collateral.oracle.toLowerCase()
+		})),
+		maturity: BigInt(parameters.obligation.maturity)
+	}]);
+	return concatHex([
+		CREATION_CODE_PREFIX,
+		numberToHex(BigInt(parameters.chainId), { size: 32 }),
+		parameters.morphoV2.toLowerCase(),
+		encodedObligation
+	]);
+}
+/**
+* Computes the same id as `IdLib.toId` in Solidity.
+* @param parameters - {@link toId.Parameters}
+* @returns The obligation id. {@link toId.ReturnType}
+*/
+function toId(parameters) {
+	return keccak256(creationCode(parameters));
+}
+
 //#endregion
 //#region src/core/Offer.ts
 /** Internal symbol for caching the computed hash. */
@@ -2168,7 +2214,6 @@ const OfferSchema = () => {
 			z$2.bigint()
 		]).optional().default("0x0000000000000000000000000000000000000000000000000000000000000000").transform(transformBytes32),
 		buy: z$2.boolean(),
-		chainId: z$2.number().min(0).max(Number.MAX_SAFE_INTEGER),
 		loanToken: z$2.string().transform(transformAddress),
 		collaterals: CollateralsSchema,
 		callback: z$2.object({
@@ -2237,7 +2282,6 @@ const serialize = (offer) => ({
 	group: offer.group,
 	session: offer.session,
 	buy: offer.buy,
-	chainId: offer.chainId,
 	loanToken: offer.loanToken,
 	collaterals: offer.collaterals.map((c) => ({
 		asset: c.asset,
@@ -2258,7 +2302,6 @@ const serialize = (offer) => ({
 * @returns {Offer} A randomly generated Offer object.
 */
 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()];
 	collateralCandidates[int(collateralCandidates.length)];
@@ -2304,7 +2347,6 @@ function random(config) {
 		group: config?.group ?? hex(32),
 		session: config?.session ?? hex(32),
 		buy,
-		chainId: chain.id,
 		loanToken,
 		collaterals: config?.collaterals ?? Array.from({ length: int(3) + 1 }, () => ({
 			...random$1(),
@@ -2324,150 +2366,138 @@ const weightedChoice = (pairs) => {
 	return pairs[0][0];
 };
 /**
-* Creates an EIP-712 domain object.
-* @param chainId - The chain ID.
-* @returns The EIP-712 domain object.
-*/
-const domain = (chainId) => ({
-	chainId: BigInt(chainId),
-	verifyingContract: zeroAddress
-});
-/**
-* The EIP-712 types for the offer.
-* @warning The ordering of the types should NEVER be changed. The offer hash is computed based on the order of the types.
-* @returns The EIP-712 types.
+* Computes the canonical chain-agnostic offer hash.
+* The hash is `keccak256(abi.encode(offer))` using {@link encode}.
+*
+* @param offer - Offer payload to hash.
+* @returns 32-byte offer hash.
 */
-const types = {
-	EIP712Domain: [{
-		name: "chainId",
-		type: "uint256"
-	}, {
-		name: "verifyingContract",
-		type: "address"
-	}],
-	Offer: [
-		{
-			name: "maker",
-			type: "address"
-		},
-		{
-			name: "assets",
-			type: "uint256"
-		},
-		{
-			name: "obligationUnits",
-			type: "uint256"
-		},
-		{
-			name: "obligationShares",
-			type: "uint256"
-		},
-		{
-			name: "tick",
-			type: "uint256"
-		},
-		{
-			name: "maturity",
-			type: "uint256"
-		},
-		{
-			name: "expiry",
-			type: "uint256"
-		},
-		{
-			name: "group",
-			type: "bytes32"
-		},
-		{
-			name: "session",
-			type: "bytes32"
-		},
-		{
-			name: "buy",
-			type: "bool"
-		},
-		{
-			name: "loanToken",
-			type: "address"
-		},
-		{
-			name: "collaterals",
-			type: "Collateral[]"
-		},
-		{
-			name: "callback",
-			type: "Callback"
-		},
-		{
-			name: "receiverIfMakerIsSeller",
-			type: "address"
-		}
-	],
-	Collateral: [
-		{
-			name: "asset",
-			type: "address"
-		},
-		{
-			name: "oracle",
-			type: "address"
-		},
-		{
-			name: "lltv",
-			type: "uint256"
-		}
-	],
-	Callback: [{
-		name: "address",
-		type: "address"
-	}, {
-		name: "data",
-		type: "bytes"
-	}]
-};
 function hash(offer) {
 	const cached = offer[HASH_CACHE];
 	if (cached) return cached;
-	const computed = hashTypedData({
-		domain: domain(offer.chainId),
-		message: {
-			maker: offer.maker.toLowerCase(),
-			assets: offer.assets,
-			obligationUnits: offer.obligationUnits,
-			obligationShares: offer.obligationShares,
-			tick: BigInt(offer.tick),
-			maturity: BigInt(offer.maturity),
-			expiry: BigInt(offer.expiry),
-			group: offer.group,
-			session: offer.session,
-			buy: offer.buy,
-			loanToken: offer.loanToken.toLowerCase(),
-			collaterals: offer.collaterals,
-			callback: {
-				address: offer.callback.address.toLowerCase(),
-				data: offer.callback.data
-			},
-			receiverIfMakerIsSeller: offer.receiverIfMakerIsSeller.toLowerCase()
-		},
-		primaryType: "Offer",
-		types
-	});
+	const computed = keccak256(encode(offer));
 	offer[HASH_CACHE] = computed;
 	return computed;
 }
 /**
-* Calculates the obligation id for an offer based on the smart contract's Obligation struct.
-* The id is computed as keccak256(abi.encode(chainId, loanToken, collaterals (sorted by token address), maturity)).
+* Calculates the onchain obligation id for an offer.
+* The id is computed with {@link Id.toId}.
 * @param offer - The offer to calculate the obligation id for.
+* @param parameters - The chain context used by the onchain id function.
 * @returns The obligation id as a 32-byte hex string.
 */
-function obligationId(offer) {
-	return id(from$13({
-		chainId: offer.chainId,
-		loanToken: offer.loanToken,
-		collaterals: offer.collaterals,
-		maturity: offer.maturity
-	}));
+function obligationId(offer, parameters) {
+	return toId({
+		chainId: parameters.chainId,
+		morphoV2: parameters.morphoV2,
+		obligation: from$13({
+			loanToken: offer.loanToken,
+			collaterals: offer.collaterals,
+			maturity: offer.maturity
+		})
+	});
+}
+const OfferAbi = [
+	{
+		name: "maker",
+		type: "address"
+	},
+	{
+		name: "assets",
+		type: "uint256"
+	},
+	{
+		name: "obligationUnits",
+		type: "uint256"
+	},
+	{
+		name: "obligationShares",
+		type: "uint256"
+	},
+	{
+		name: "tick",
+		type: "uint256"
+	},
+	{
+		name: "maturity",
+		type: "uint256"
+	},
+	{
+		name: "expiry",
+		type: "uint256"
+	},
+	{
+		name: "group",
+		type: "bytes32"
+	},
+	{
+		name: "session",
+		type: "bytes32"
+	},
+	{
+		name: "buy",
+		type: "bool"
+	},
+	{
+		name: "loanToken",
+		type: "address"
+	},
+	{
+		name: "start",
+		type: "uint256"
+	},
+	{
+		name: "collaterals",
+		type: "tuple[]",
+		components: [
+			{
+				name: "asset",
+				type: "address"
+			},
+			{
+				name: "oracle",
+				type: "address"
+			},
+			{
+				name: "lltv",
+				type: "uint256"
+			}
+		]
+	},
+	{
+		name: "callback",
+		type: "tuple",
+		components: [{
+			name: "address",
+			type: "address"
+		}, {
+			name: "data",
+			type: "bytes"
+		}]
+	},
+	{
+		name: "receiverIfMakerIsSeller",
+		type: "address"
+	}
+];
+function encode(offer) {
+	return encodeAbiParameters(OfferAbi, [
+		offer.maker,
+		offer.assets,
+		offer.obligationUnits,
+		offer.obligationShares,
+		BigInt(offer.tick),
+		BigInt(offer.maturity),
+		BigInt(offer.expiry),
+		offer.group,
+		offer.session,
+		offer.buy,
+		offer.loanToken,
+		BigInt(offer.start),
+		offer.collaterals,
+		offer.callback,
+		offer.receiverIfMakerIsSeller
+	]);
 }
 /**
 * ABI for the Take event emitted by the Morpho V2 contract.
@@ -2591,6 +2621,189 @@ const consumedEvent = {
 	],
 	anonymous: false
 };
+/**
+* ABI for the Repay event emitted by the MorphoV2 contract.
+*/
+const repayEvent = {
+	type: "event",
+	name: "Repay",
+	inputs: [
+		{
+			name: "caller",
+			type: "address",
+			indexed: true,
+			internalType: "address"
+		},
+		{
+			name: "id",
+			type: "bytes32",
+			indexed: true,
+			internalType: "bytes32"
+		},
+		{
+			name: "obligationUnits",
+			type: "uint256",
+			indexed: false,
+			internalType: "uint256"
+		},
+		{
+			name: "onBehalf",
+			type: "address",
+			indexed: true,
+			internalType: "address"
+		}
+	],
+	anonymous: false
+};
+/**
+* ABI for the Liquidate event emitted by the MorphoV2 contract.
+*/
+const liquidateEvent = {
+	type: "event",
+	name: "Liquidate",
+	inputs: [
+		{
+			name: "caller",
+			type: "address",
+			indexed: true,
+			internalType: "address"
+		},
+		{
+			name: "id",
+			type: "bytes32",
+			indexed: true,
+			internalType: "bytes32"
+		},
+		{
+			name: "seizures",
+			type: "tuple[]",
+			indexed: false,
+			internalType: "struct IMorphoV2.Seizure[]",
+			components: [
+				{
+					name: "collateralIndex",
+					type: "uint256",
+					internalType: "uint256"
+				},
+				{
+					name: "repaid",
+					type: "uint256",
+					internalType: "uint256"
+				},
+				{
+					name: "seized",
+					type: "uint256",
+					internalType: "uint256"
+				}
+			]
+		},
+		{
+			name: "borrower",
+			type: "address",
+			indexed: true,
+			internalType: "address"
+		},
+		{
+			name: "totalRepaid",
+			type: "uint256",
+			indexed: false,
+			internalType: "uint256"
+		},
+		{
+			name: "badDebt",
+			type: "uint256",
+			indexed: false,
+			internalType: "uint256"
+		}
+	],
+	anonymous: false
+};
+/**
+* ABI for the SupplyCollateral event emitted by the MorphoV2 contract.
+*/
+const supplyCollateralEvent = {
+	type: "event",
+	name: "SupplyCollateral",
+	inputs: [
+		{
+			name: "caller",
+			type: "address",
+			indexed: false,
+			internalType: "address"
+		},
+		{
+			name: "id",
+			type: "bytes32",
+			indexed: true,
+			internalType: "bytes32"
+		},
+		{
+			name: "collateral",
+			type: "address",
+			indexed: true,
+			internalType: "address"
+		},
+		{
+			name: "assets",
+			type: "uint256",
+			indexed: false,
+			internalType: "uint256"
+		},
+		{
+			name: "onBehalf",
+			type: "address",
+			indexed: true,
+			internalType: "address"
+		}
+	],
+	anonymous: false
+};
+/**
+* ABI for the WithdrawCollateral event emitted by the MorphoV2 contract.
+*/
+const withdrawCollateralEvent = {
+	type: "event",
+	name: "WithdrawCollateral",
+	inputs: [
+		{
+			name: "caller",
+			type: "address",
+			indexed: false,
+			internalType: "address"
+		},
+		{
+			name: "id",
+			type: "bytes32",
+			indexed: true,
+			internalType: "bytes32"
+		},
+		{
+			name: "collateral",
+			type: "address",
+			indexed: true,
+			internalType: "address"
+		},
+		{
+			name: "assets",
+			type: "uint256",
+			indexed: false,
+			internalType: "uint256"
+		},
+		{
+			name: "onBehalf",
+			type: "address",
+			indexed: true,
+			internalType: "address"
+		},
+		{
+			name: "receiver",
+			type: "address",
+			indexed: false,
+			internalType: "address"
+		}
+	],
+	anonymous: false
+};
 var InvalidOfferError = class InvalidOfferError extends BaseError {
 	name = "Offer.InvalidOfferError";
 	constructor(error) {
@@ -2649,6 +2862,8 @@ let Conversion;
 let Type = /* @__PURE__ */ function(Type) {
 	Type["ERC20"] = "erc20";
 	Type["VAULT_V1"] = "vault_v1";
+	Type["DEBT_OF"] = "debtOf";
+	Type["COLLATERAL_OF"] = "collateralOf";
 	return Type;
 }({});
 /**
@@ -2664,10 +2879,16 @@ function from$10(parameters) {
 		user: parameters.user.toLowerCase(),
 		type: parameters.type,
 		balance: parameters.balance,
-		...parameters.asset !== void 0 ? { asset: parameters.asset.toLowerCase() } : {},
+		asset: parameters.asset.toLowerCase(),
 		blockNumber: parameters.blockNumber
 	};
 }
+/**
+* Maps a {@link Type} enum value to its 1-based integer ID used in the database.
+* @param type - The position type.
+* @returns The 1-based integer ID.
+*/
+const positionTypeId = (type) => Object.values(Type).indexOf(type) + 1;
 
 //#endregion
 //#region src/core/Tick.ts
@@ -2784,6 +3005,8 @@ function from$8(parameters) {
 		from: parameters.from.toLowerCase(),
 		to: parameters.to.toLowerCase(),
 		value: parameters.value,
+		type: parameters.type,
+		asset: parameters.asset.toLowerCase(),
 		blockNumber: parameters.blockNumber
 	};
 }
@@ -2912,14 +3135,10 @@ const encodeUnsigned = (tree) => {
 	validateTreeForEncoding(tree);
 	return bytesToHex(encodeUnsignedBytes(tree));
 };
-const validateTreeForEncoding = (tree, domain) => {
+const validateTreeForEncoding = (tree) => {
 	if (VERSION$1 > 255) throw new EncodeError(`version overflow: ${VERSION$1} exceeds 255`);
 	const computed = from$7(tree.offers);
 	if (tree.root !== computed.root) throw new EncodeError(`root mismatch: expected ${computed.root}, got ${tree.root}`);
-	if (domain) {
-		const mismatched = tree.offers.find((offer) => BigInt(offer.chainId) !== domain.chainId);
-		if (mismatched) throw new EncodeError(`chainId mismatch: expected ${domain.chainId}, got ${mismatched.chainId}`);
-	}
 };
 const encodeUnsignedBytes = (tree) => {
 	const offersPayload = tree.offers.map(serialize);
@@ -2986,8 +3205,6 @@ const decode = async (encoded, domain) => {
 	}
 	const tree = from$7(rawOffers.map((o) => OfferSchema().parse(o)));
 	if (root !== tree.root) throw new DecodeError(`root mismatch: expected ${tree.root}, got ${root}`);
-	const chainIdMismatch = tree.offers.find((offer) => BigInt(offer.chainId) !== normalizedDomain.chainId);
-	if (chainIdMismatch) throw new DecodeError(`chainId mismatch: expected ${normalizedDomain.chainId}, got ${chainIdMismatch.chainId}`);
 	return {
 		tree,
 		signature,
@@ -3031,10 +3248,6 @@ const BrandTypeId = Symbol.for("mempool/Brand");
 
 //#endregion
 //#region src/gatekeeper/Rules.ts
-const chains$1 = ({ chains }) => single("chain_ids", `Validates that offer chain is one of: [${chains.map((c) => c.id).join(", ")}]`, (offer) => {
-	const allowedChainIds = chains.map((c) => c.id);
-	if (!allowedChainIds.some((id) => id === offer.chainId)) return { message: `Chain ID ${offer.chainId} is not in the allowed chains (${allowedChainIds.join(", ")})` };
-});
 const maturity = ({ maturities }) => single("maturity", `Validates that offer maturity is one of: [${maturities.join(", ")}]`, (offer) => {
 	const allowedMaturities = maturities.map((m) => from$16(m));
 	if (!allowedMaturities.includes(offer.maturity)) return { message: `Maturity must be one of (${allowedMaturities.join(", ")}). Got: ${offer.maturity}` };
@@ -3049,9 +3262,9 @@ const callback = ({ callbacks }) => single("callback", `Validates callbacks: buy
 * @param assetsByChainId - Allowed loan tokens indexed by chain id.
 * @returns The issue that was found. If the offer is valid, this will be undefined.
 */
-const loanToken = ({ assetsByChainId }) => single("loan_token", "Validates that offer loan token is in the allowed token list for the offer chain", (offer) => {
-	const allowedLoanTokens = assetsByChainId[offer.chainId]?.map((asset) => asset.toLowerCase());
-	if (!allowedLoanTokens || allowedLoanTokens.length === 0) return { message: `No allowed loan tokens for chain ${offer.chainId}` };
+const loanToken = ({ assetsByChainId, chainId }) => single("loan_token", "Validates that offer loan token is in the allowed token list for the request chain", (offer) => {
+	const allowedLoanTokens = assetsByChainId[chainId]?.map((asset) => asset.toLowerCase());
+	if (!allowedLoanTokens || allowedLoanTokens.length === 0) return { message: `No allowed loan tokens for chain ${chainId}` };
 	if (!allowedLoanTokens.includes(offer.loanToken.toLowerCase())) return { message: "Loan token is not allowed" };
 });
 /**
@@ -3059,9 +3272,9 @@ const loanToken = ({ assetsByChainId }) => single("loan_token", "Validates that
 * @param collateralAssetsByChainId - Allowed collateral tokens indexed by chain id.
 * @returns The issue that was found. If the offer is valid, this will be undefined.
 */
-const collateralToken = ({ collateralAssetsByChainId }) => single("collateral_token", "Validates that offer collateral tokens are in the allowed token list for the offer chain", (offer) => {
-	const allowedCollateralTokens = collateralAssetsByChainId[offer.chainId]?.map((asset) => asset.toLowerCase()) ?? [];
-	if (allowedCollateralTokens.length === 0) return { message: `No allowed collateral tokens for chain ${offer.chainId}` };
+const collateralToken = ({ collateralAssetsByChainId, chainId }) => single("collateral_token", "Validates that offer collateral tokens are in the allowed token list for the request chain", (offer) => {
+	const allowedCollateralTokens = collateralAssetsByChainId[chainId]?.map((asset) => asset.toLowerCase()) ?? [];
+	if (allowedCollateralTokens.length === 0) return { message: `No allowed collateral tokens for chain ${chainId}` };
 	if (offer.collaterals.length === 0) return { message: "At least one collateral token is required" };
 	if (offer.collaterals.some((collateral) => !allowedCollateralTokens.includes(collateral.asset.toLowerCase()))) return { message: "Collateral token is not allowed" };
 });
@@ -3070,9 +3283,9 @@ const collateralToken = ({ collateralAssetsByChainId }) => single("collateral_to
 * @param oraclesByChainId - Allowed oracles indexed by chain id.
 * @returns The issue that was found. If the offer is valid, this will be undefined.
 */
-const oracle = ({ oraclesByChainId }) => single("oracle", "Validates that offer collateral oracles are in the allowed oracle list for the offer chain", (offer) => {
-	const allowedOracles = oraclesByChainId[offer.chainId]?.map((oracle) => oracle.toLowerCase());
-	if (!allowedOracles || allowedOracles.length === 0) return { message: `No allowed oracles for chain ${offer.chainId}` };
+const oracle = ({ oraclesByChainId, chainId }) => single("oracle", "Validates that offer collateral oracles are in the allowed oracle list for the request chain", (offer) => {
+	const allowedOracles = oraclesByChainId[chainId]?.map((oracle) => oracle.toLowerCase());
+	if (!allowedOracles || allowedOracles.length === 0) return { message: `No allowed oracles for chain ${chainId}` };
 	if (offer.collaterals.some((collateral) => !allowedOracles.includes(collateral.oracle.toLowerCase()))) return { message: "Oracle is not allowed" };
 });
 /**
@@ -3104,7 +3317,8 @@ const amountMutualExclusivity = () => single("amount_mutual_exclusivity", "Valid
 
 //#endregion
 //#region src/gatekeeper/morphoRules.ts
-const morphoRules = (chains) => {
+const morphoRules = (parameters) => {
+	const { chains, chainId } = parameters;
 	const assetsByChainId = {};
 	const collateralAssetsByChainId = {};
 	const oraclesByChainId = {};
@@ -3116,15 +3330,23 @@ const morphoRules = (chains) => {
 	return [
 		sameMaker(),
 		amountMutualExclusivity(),
-		chains$1({ chains }),
 		maturity({ maturities: [MaturityType.EndOfWeek, MaturityType.EndOfNextWeek] }),
 		callback({
 			callbacks: [Type$1.BuyWithEmptyCallback, Type$1.SellWithEmptyCallback],
 			allowedAddresses: []
 		}),
-		loanToken({ assetsByChainId }),
-		collateralToken({ collateralAssetsByChainId }),
-		oracle({ oraclesByChainId })
+		loanToken({
+			assetsByChainId,
+			chainId
+		}),
+		collateralToken({
+			collateralAssetsByChainId,
+			chainId
+		}),
+		oracle({
+			oraclesByChainId,
+			chainId
+		})
 	];
 };
 
@@ -3266,12 +3488,13 @@ const RouterStatusResponse = z$1.object({
 * @constructor
 * @param obligation - {@link Obligation}
 * @param quote - {@link Quote}
+* @param chainId - The chain id used to compute `id`.
 * @returns The created `ObligationResponse`. {@link ObligationResponse}
 */
-function from$5(obligation, quote) {
+function from$5(obligation, quote, chainId) {
 	return {
 		id: quote.obligationId,
-		chain_id: obligation.chainId,
+		chain_id: chainId,
 		loan_token: obligation.loanToken,
 		collaterals: obligation.collaterals.map((c) => ({
 			token: c.asset,
@@ -3337,12 +3560,7 @@ function from$4(input) {
 			receiver_if_maker_is_seller: input.receiverIfMakerIsSeller
 		},
 		offer_hash: input.hash,
-		obligation_id: id({
-			chainId,
-			loanToken: input.loanToken,
-			collaterals: [...input.collaterals],
-			maturity: input.maturity
-		}),
+		obligation_id: input.obligationId,
 		chain_id: chainId,
 		consumed: input.consumed.toString(),
 		takeable: input.takeable.toString(),
@@ -3969,10 +4187,6 @@ __decorate([ApiProperty({
 	type: "boolean",
 	example: validateOfferExample.buy
 })], ValidateOfferRequest.prototype, "buy", void 0);
-__decorate([ApiProperty({
-	type: "number",
-	example: validateOfferExample.chain_id
-})], ValidateOfferRequest.prototype, "chain_id", void 0);
 __decorate([ApiProperty({
 	type: "string",
 	example: validateOfferExample.loan_token
@@ -3990,6 +4204,11 @@ __decorate([ApiProperty({
 	example: validateOfferExample.receiver_if_maker_is_seller
 })], ValidateOfferRequest.prototype, "receiver_if_maker_is_seller", void 0);
 var ValidateOffersRequest = class {};
+__decorate([ApiProperty({
+	type: "number",
+	description: "Chain id used for chain-scoped validation rules.",
+	example: validateOfferExample.chain_id
+})], ValidateOffersRequest.prototype, "chain_id", void 0);
 __decorate([ApiProperty({
 	type: () => [ValidateOfferRequest],
 	description: "Array of offers in snake_case format. Required, non-empty.",
@@ -4755,6 +4974,12 @@ function isValidBase64urlJson(val) {
 function isValidOfferHashCursor(val) {
 	return /^0x[a-f0-9]{64}$/i.test(val);
 }
+function isValidOfferCursor(val) {
+	const [hash, obligationId, ...rest] = val.split(":");
+	if (rest.length !== 0) return false;
+	if (!hash || !obligationId) return false;
+	return isValidOfferHashCursor(hash) && isValidOfferHashCursor(obligationId);
+}
 const csvArray = (schema) => z$2.preprocess((value) => {
 	if (value === void 0) return void 0;
 	if (Array.isArray(value)) {
@@ -4818,7 +5043,7 @@ const GetConfigContractsQueryParams = z$2.object({
 });
 const GetOffersQueryParams = PaginationQueryParams.omit({ cursor: true }).extend({
 	cursor: z$2.string().optional().meta({
-		description: "Pagination cursor. Use offer hash (0x...) for maker queries, base64url for obligation queries.",
+		description: "Pagination cursor. Use offer hash:obligation_id for maker queries, base64url for obligation queries.",
 		example: "eyJzaWRlIjoic2VsbCIsImN1cnJlbnRQcmljZSI6IjEwMDAwMDAwMDAwMDAwMDAwMDAiLCJibG9ja051bWJlciI6MSwiYXNzZXRzIjoiMTAwMDAwMDAwMDAwMDAwMDAwMCIsImhhc2giOiIweGRmZDY4NTllM2UwODJkMTkzODlhMWFlYzFiZGFkN2U4ZDkyZDk2YjFhYTc5NDBkYTkxYTMxMjVkMzFlM2JlNWIiLCJ0b3RhbFJldHVybmVkIjoxMCwibm93IjoxNjAwMDAwMDAwfQ"
 	}),
 	side: z$2.enum(["buy", "sell"]).optional().meta({
@@ -4845,10 +5070,10 @@ const GetOffersQueryParams = PaginationQueryParams.omit({ cursor: true }).extend
 		return;
 	}
 	if (hasMaker) {
-		if (val.cursor !== void 0 && !isValidOfferHashCursor(val.cursor)) ctx.addIssue({
+		if (val.cursor !== void 0 && !isValidOfferCursor(val.cursor)) ctx.addIssue({
 			code: "custom",
 			path: ["cursor"],
-			message: "Cursor must be a 32-byte hex offer hash when filtering by maker"
+			message: "Cursor must be in the offer hash:obligation_id format when filtering by maker"
 		});
 		return;
 	}
@@ -4958,7 +5183,13 @@ const GetBookParams = z$2.object({
 		example: "buy"
 	})
 });
-const ValidateOffersBody = z$2.object({ offers: z$2.array(z$2.unknown()).min(1, { message: "'offers' must contain at least 1 offer" }) }).strict();
+const ValidateOffersBody = z$2.object({
+	chain_id: z$2.number().int().positive("chain_id must be a positive integer").meta({
+		description: "Chain id used for chain-scoped validation rules.",
+		example: 1
+	}),
+	offers: z$2.array(z$2.unknown()).min(1, { message: "'offers' must contain at least 1 offer" })
+}).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({
@@ -5005,7 +5236,7 @@ async function getConfigRules(query, chains) {
 	const checksum = buildConfigRulesChecksum(filteredRules);
 	let cursorRule = null;
 	if (cursor) try {
-		cursorRule = parseCursor$1(cursor);
+		cursorRule = parseCursor$3(cursor);
 	} catch (err) {
 		return failure(err);
 	}
@@ -5013,7 +5244,7 @@ async function getConfigRules(query, chains) {
 	if (cursorRule && chainFilter && !chainFilter.has(cursorRule.chain_id)) return failure(new BadRequestError$1("Cursor chain_id must match requested chains"));
 	const startIndex = cursorRule ? findStartIndex$1(filteredRules, cursorRule) : 0;
 	const page = filteredRules.slice(startIndex, startIndex + limit);
-	const nextCursor = startIndex + limit < filteredRules.length && page.length > 0 ? formatCursor$1(page.at(-1)) : null;
+	const nextCursor = startIndex + limit < filteredRules.length && page.length > 0 ? formatCursor$3(page.at(-1)) : null;
 	const response = success({
 		data: page,
 		cursor: nextCursor
@@ -5021,14 +5252,14 @@ async function getConfigRules(query, chains) {
 	response.body.meta.checksum = checksum;
 	return response;
 }
-function formatCursor$1(rule) {
+function formatCursor$3(rule) {
 	if (rule.type === "maturity") return `maturity:${rule.chain_id}:${rule.timestamp}:${rule.name}`;
 	if (rule.type === "callback") return `callback:${rule.chain_id}:${rule.callback_type}:${rule.address.toLowerCase()}`;
 	if (rule.type === "oracle") return `oracle:${rule.chain_id}:${rule.address.toLowerCase()}`;
 	if (rule.type === "collateral_token") return `collateral_token:${rule.chain_id}:${rule.address.toLowerCase()}`;
 	return `loan_token:${rule.chain_id}:${rule.address.toLowerCase()}`;
 }
-function parseCursor$1(cursor) {
+function parseCursor$3(cursor) {
 	const [type, chain, ...rest] = cursor.split(":");
 	if (!type || !chain || rest.length === 0) throw new BadRequestError$1("Cursor must be in the format type:chain_id:<value>");
 	if (!isConfigRuleType(type)) throw new BadRequestError$1("Cursor has an invalid rule type");
@@ -5178,16 +5409,17 @@ async function validateOffers(body, gatekeeper) {
 	const logger = getLogger();
 	const result = safeParse("validate_offers", body, (issue) => issue.message);
 	if (!result.success) return failure(new BadRequestError$1(result.error.issues[0]?.message ?? "Invalid request body"));
-	const { offers: rawOffers } = result.data;
+	const { offers: rawOffers, chain_id: rawChainId } = result.data;
+	const chainId = rawChainId;
 	const parsedOffers = [];
 	const offerIndexByHash = /* @__PURE__ */ new Map();
 	for (let i = 0; i < rawOffers.length; i++) {
 		const rawOffer = rawOffers[i];
 		try {
 			const offer = fromSnakeCase(rawOffer);
-			const hash$3 = hash(offer);
-			if (!offerIndexByHash.has(hash$3)) {
-				offerIndexByHash.set(hash$3, i);
+			const hash$1 = hash(offer);
+			if (!offerIndexByHash.has(hash$1)) {
+				offerIndexByHash.set(hash$1, i);
 				parsedOffers.push(offer);
 			}
 		} catch (err) {
@@ -5197,7 +5429,10 @@ async function validateOffers(body, gatekeeper) {
 		}
 	}
 	try {
-		const { issues } = await gatekeeper.isAllowed(parsedOffers);
+		const { issues } = await gatekeeper.isAllowed({
+			offers: parsedOffers,
+			chainId
+		});
 		if (issues.length > 0) {
 			const mappedIssues = issues.map((issue) => {
 				const index = offerIndexByHash.get(hash(issue.item));
@@ -5358,7 +5593,7 @@ function now() {
 
 //#endregion
 //#region src/database/drizzle/VERSION.ts
-const VERSION = "router_v1.8";
+const VERSION = "router_v1.11";
 
 //#endregion
 //#region src/database/drizzle/schema.ts
@@ -5373,8 +5608,10 @@ var schema_exports = /* @__PURE__ */ __exportAll({
 	consumedEvents: () => consumedEvents,
 	groups: () => groups,
 	lots: () => lots,
+	lotsPositions: () => lotsPositions,
 	merklePaths: () => merklePaths,
 	obligationCollateralsV2: () => obligationCollateralsV2,
+	obligationIdKeys: () => obligationIdKeys,
 	obligations: () => obligations,
 	offers: () => offers,
 	offersCallbacks: () => offersCallbacks,
@@ -5390,6 +5627,7 @@ var schema_exports = /* @__PURE__ */ __exportAll({
 const s = pgSchema(VERSION);
 var EnumTableName = /* @__PURE__ */ function(EnumTableName) {
 	EnumTableName["OBLIGATIONS"] = "obligations";
+	EnumTableName["OBLIGATION_ID_KEYS"] = "obligation_id_keys";
 	EnumTableName["GROUPS"] = "groups";
 	EnumTableName["CONSUMED_EVENTS"] = "consumed_events";
 	EnumTableName["OBLIGATION_COLLATERALS_V2"] = "obligation_collaterals_v2";
@@ -5403,6 +5641,7 @@ var EnumTableName = /* @__PURE__ */ function(EnumTableName) {
 	EnumTableName["COLLECTORS"] = "collectors";
 	EnumTableName["CHAINS"] = "chains";
 	EnumTableName["LOTS"] = "lots";
+	EnumTableName["LOTS_POSITIONS"] = "lots_positions";
 	EnumTableName["OFFSETS"] = "offsets";
 	EnumTableName["TREES"] = "trees";
 	EnumTableName["MERKLE_PATHS"] = "merkle_paths";
@@ -5411,11 +5650,16 @@ var EnumTableName = /* @__PURE__ */ function(EnumTableName) {
 const TABLE_NAMES = Object.values(EnumTableName);
 const VERSIONED_TABLE_NAMES = TABLE_NAMES.map((table) => `"${VERSION}"."${table}"`);
 const obligations = s.table(EnumTableName.OBLIGATIONS, {
-	obligationId: varchar("obligation_id", { length: 66 }).primaryKey(),
-	chainId: bigint("chain_id", { mode: "number" }).$type().notNull(),
+	obligationKey: varchar("obligation_key", { length: 66 }).primaryKey(),
 	loanToken: varchar("loan_token", { length: 42 }).notNull(),
 	maturity: integer("maturity").notNull()
 });
+const obligationIdKeys = s.table(EnumTableName.OBLIGATION_ID_KEYS, {
+	obligationId: varchar("obligation_id", { length: 66 }).primaryKey(),
+	obligationKey: varchar("obligation_key", { length: 66 }).notNull().references(() => obligations.obligationKey, { onDelete: "cascade" }),
+	chainId: bigint("chain_id", { mode: "number" }).$type().notNull(),
+	morphoV2: varchar("morpho_v2", { length: 42 }).notNull()
+}, (table) => [index("obligation_id_keys_obligation_key_idx").on(table.obligationKey), index("obligation_id_keys_chain_id_idx").on(table.chainId)]);
 const groups = s.table(EnumTableName.GROUPS, {
 	chainId: bigint("chain_id", { mode: "number" }).$type().notNull(),
 	maker: varchar("maker", { length: 42 }).notNull(),
@@ -5463,24 +5707,19 @@ const consumedEvents = s.table(EnumTableName.CONSUMED_EVENTS, {
 	index("consumed_events_block_number_idx").on(t.blockNumber)
 ]);
 const obligationCollateralsV2 = s.table(EnumTableName.OBLIGATION_COLLATERALS_V2, {
-	obligationId: varchar("obligation_id", { length: 66 }).notNull().references(() => obligations.obligationId, { onDelete: "cascade" }),
+	obligationKey: varchar("obligation_key", { length: 66 }).notNull().references(() => obligations.obligationKey, { onDelete: "cascade" }),
 	asset: varchar("asset", { length: 42 }).notNull(),
-	oracleChainId: bigint("oracle_chain_id", { mode: "number" }).$type().notNull(),
 	oracleAddress: varchar("oracle_address", { length: 42 }).notNull(),
 	lltv: bigint("lltv", { mode: "bigint" }).notNull(),
+	collateralIndex: integer("collateral_index").notNull(),
 	updatedAt: timestamp("updated_at").defaultNow().notNull()
 }, (table) => [
 	primaryKey({
-		columns: [table.obligationId, table.asset],
+		columns: [table.obligationKey, table.asset],
 		name: "obligation_collaterals_v2_pk"
 	}),
-	foreignKey({
-		columns: [table.oracleChainId, table.oracleAddress],
-		foreignColumns: [oracles.chainId, oracles.address],
-		name: "obligation_collaterals_v2_oracles_fk"
-	}),
-	index("obligation_collaterals_v2_obligation_id_idx").on(table.obligationId),
-	index("obligation_collaterals_v2_oracle_fk_idx").on(table.oracleChainId, table.oracleAddress)
+	index("obligation_collaterals_v2_obligation_key_idx").on(table.obligationKey),
+	index("obligation_collaterals_v2_oracle_address_idx").on(table.oracleAddress)
 ]);
 const oracles = s.table(EnumTableName.ORACLES, {
 	chainId: bigint("chain_id", { mode: "number" }).$type().notNull(),
@@ -5496,8 +5735,8 @@ const oracles = s.table(EnumTableName.ORACLES, {
 	name: "oracles_pk"
 })]);
 const offers = s.table(EnumTableName.OFFERS, {
-	hash: varchar("hash", { length: 66 }).primaryKey(),
-	obligationId: varchar("obligation_id", { length: 66 }).notNull().references(() => obligations.obligationId, { onDelete: "cascade" }),
+	hash: varchar("hash", { length: 66 }).notNull(),
+	obligationId: varchar("obligation_id", { length: 66 }).notNull().references(() => obligationIdKeys.obligationId, { onDelete: "cascade" }),
 	assets: numeric("assets", {
 		precision: 78,
 		scale: 0
@@ -5525,6 +5764,10 @@ const offers = s.table(EnumTableName.OFFERS, {
 	blockNumber: bigint("block_number", { mode: "number" }).notNull(),
 	updatedAt: timestamp("updated_at").defaultNow().notNull()
 }, (table) => [
+	primaryKey({
+		columns: [table.hash, table.obligationId],
+		name: "offers_pk"
+	}),
 	foreignKey({
 		columns: [
 			table.groupChainId,
@@ -5543,10 +5786,19 @@ const offers = s.table(EnumTableName.OFFERS, {
 	index("offers_obligation_id_side_idx").on(table.obligationId, table.buy)
 ]);
 const offersCallbacks = s.table(EnumTableName.OFFERS_CALLBACKS, {
-	offerHash: varchar("offer_hash", { length: 66 }).notNull().references(() => offers.hash, { onDelete: "cascade" }),
+	offerHash: varchar("offer_hash", { length: 66 }).notNull(),
+	obligationId: varchar("obligation_id", { length: 66 }).notNull(),
 	callbackId: varchar("callback_id", { length: 66 })
-}, (table) => [primaryKey({
-	columns: [table.offerHash, table.callbackId],
+}, (table) => [foreignKey({
+	columns: [table.offerHash, table.obligationId],
+	foreignColumns: [offers.hash, offers.obligationId],
+	name: "offers_callbacks_offer_fk"
+}).onDelete("cascade"), primaryKey({
+	columns: [
+		table.offerHash,
+		table.obligationId,
+		table.callbackId
+	],
 	name: "offers_callbacks_pk"
 })]);
 const callbacks = s.table(EnumTableName.CALLBACKS, {
@@ -5554,23 +5806,25 @@ const callbacks = s.table(EnumTableName.CALLBACKS, {
 	positionChainId: bigint("position_chain_id", { mode: "number" }).$type().notNull(),
 	positionContract: varchar("position_contract", { length: 42 }).notNull(),
 	positionUser: varchar("position_user", { length: 42 }).notNull(),
+	positionTypeId: integer("position_type_id").notNull().references(() => positionTypes.id, { onDelete: "no action" }),
 	amount: numeric("amount", {
 		precision: 78,
 		scale: 0
 	})
-}, (table) => [foreignKey({
+});
+const lotsPositions = s.table(EnumTableName.LOTS_POSITIONS, {
+	chainId: bigint("chain_id", { mode: "number" }).$type().notNull(),
+	contract: varchar("contract", { length: 42 }).notNull(),
+	user: varchar("user", { length: 42 }).notNull(),
+	positionTypeId: integer("position_type_id").notNull().references(() => positionTypes.id, { onDelete: "no action" })
+}, (table) => [primaryKey({
 	columns: [
-		table.positionChainId,
-		table.positionContract,
-		table.positionUser
-	],
-	foreignColumns: [
-		positions.chainId,
-		positions.contract,
-		positions.user
+		table.chainId,
+		table.contract,
+		table.user
 	],
-	name: "callbacks_positions_fk"
-}).onDelete("cascade")]);
+	name: "lots_positions_pk"
+})]);
 const lots = s.table(EnumTableName.LOTS, {
 	chainId: bigint("chain_id", { mode: "number" }).$type().notNull(),
 	user: varchar("user", { length: 42 }).notNull(),
@@ -5603,11 +5857,11 @@ const lots = s.table(EnumTableName.LOTS, {
 			table.user
 		],
 		foreignColumns: [
-			positions.chainId,
-			positions.contract,
-			positions.user
+			lotsPositions.chainId,
+			lotsPositions.contract,
+			lotsPositions.user
 		],
-		name: "lots_positions_fk"
+		name: "lots_lots_positions_fk"
 	}).onDelete("cascade"),
 	foreignKey({
 		columns: [
@@ -5649,11 +5903,11 @@ const offsets = s.table(EnumTableName.OFFSETS, {
 		table.user
 	],
 	foreignColumns: [
-		positions.chainId,
-		positions.contract,
-		positions.user
+		lotsPositions.chainId,
+		lotsPositions.contract,
+		lotsPositions.user
 	],
-	name: "offsets_positions_fk"
+	name: "offsets_lots_positions_fk"
 }).onDelete("cascade")]);
 const PositionTypes = s.enum("position_type", Object.values(Type));
 const positionTypes = s.table("position_types", {
@@ -5662,34 +5916,38 @@ const positionTypes = s.table("position_types", {
 });
 const positions = s.table(EnumTableName.POSITIONS, {
 	chainId: bigint("chain_id", { mode: "number" }).$type().notNull(),
-	contract: varchar("contract", { length: 42 }).notNull(),
+	contract: varchar("contract", { length: 66 }).notNull(),
 	user: varchar("user", { length: 42 }).notNull(),
 	positionTypeId: integer("position_type_id").notNull().references(() => positionTypes.id, { onDelete: "no action" }),
 	balance: numeric("balance", {
 		precision: 78,
 		scale: 0
 	}),
-	asset: varchar("asset", { length: 42 }),
+	asset: varchar("asset", { length: 42 }).notNull(),
 	blockNumber: bigint("block_number", { mode: "number" }).notNull(),
 	updatedAt: timestamp("updated_at").defaultNow().notNull()
 }, (table) => [primaryKey({
 	columns: [
 		table.chainId,
 		table.contract,
-		table.user
+		table.user,
+		table.positionTypeId,
+		table.asset
 	],
 	name: "positions_pk"
 })]);
 const transfers = s.table(EnumTableName.TRANSFERS, {
 	eventId: varchar("event_id", { length: 128 }).primaryKey(),
 	chainId: bigint("chain_id", { mode: "number" }).$type().notNull(),
-	contract: varchar("contract", { length: 42 }).notNull(),
+	contract: varchar("contract", { length: 66 }).notNull(),
 	from: varchar("from", { length: 42 }).notNull(),
 	to: varchar("to", { length: 42 }).notNull(),
 	value: numeric("value", {
 		precision: 78,
 		scale: 0
 	}).notNull(),
+	positionTypeId: integer("position_type_id").notNull().references(() => positionTypes.id, { onDelete: "no action" }),
+	asset: varchar("asset", { length: 42 }).notNull(),
 	blockNumber: bigint("block_number", { mode: "number" }).notNull(),
 	createdAt: timestamp("created_at").defaultNow().notNull()
 }, (table) => [
@@ -5697,12 +5955,16 @@ const transfers = s.table(EnumTableName.TRANSFERS, {
 		columns: [
 			table.chainId,
 			table.contract,
-			table.from
+			table.from,
+			table.positionTypeId,
+			table.asset
 		],
 		foreignColumns: [
 			positions.chainId,
 			positions.contract,
-			positions.user
+			positions.user,
+			positions.positionTypeId,
+			positions.asset
 		],
 		name: "transfers_positions_from_fk"
 	}).onDelete("cascade"),
@@ -5710,16 +5972,21 @@ const transfers = s.table(EnumTableName.TRANSFERS, {
 		columns: [
 			table.chainId,
 			table.contract,
-			table.to
+			table.to,
+			table.positionTypeId,
+			table.asset
 		],
 		foreignColumns: [
 			positions.chainId,
 			positions.contract,
-			positions.user
+			positions.user,
+			positions.positionTypeId,
+			positions.asset
 		],
 		name: "transfers_positions_to_fk"
 	}).onDelete("cascade"),
-	index("transfers_chain_contract_user_idx").on(table.chainId, table.contract, table.from, table.to, table.blockNumber)
+	index("transfers_chain_contract_user_idx").on(table.chainId, table.contract, table.from, table.to, table.blockNumber),
+	index("transfers_chain_type_block_idx").on(table.chainId, table.positionTypeId, table.blockNumber)
 ]);
 const StatusCode = s.enum("status_code", Object.values(Status));
 const status = s.table("status", {
@@ -5727,10 +5994,18 @@ const status = s.table("status", {
 	code: StatusCode("code").unique()
 });
 const validations = s.table("validations", {
-	offerHash: varchar("offer_hash", { length: 66 }).primaryKey().references(() => offers.hash, { onDelete: "cascade" }),
+	offerHash: varchar("offer_hash", { length: 66 }).notNull(),
+	obligationId: varchar("obligation_id", { length: 66 }).notNull(),
 	statusId: integer("status_id").notNull().references(() => status.id, { onDelete: "no action" }),
 	updatedAt: timestamp("updated_at").defaultNow().notNull()
-});
+}, (table) => [primaryKey({
+	columns: [table.offerHash, table.obligationId],
+	name: "validations_pk"
+}), foreignKey({
+	columns: [table.offerHash, table.obligationId],
+	foreignColumns: [offers.hash, offers.obligationId],
+	name: "validations_offer_fk"
+}).onDelete("cascade")]);
 const collectors = s.table(EnumTableName.COLLECTORS, {
 	chainId: bigint("chain_id", { mode: "number" }).$type().notNull().references(() => chains.chainId, { onDelete: "no action" }),
 	name: text("name").$type().notNull(),
@@ -5756,18 +6031,352 @@ const trees = s.table(EnumTableName.TREES, {
 	createdAt: timestamp("created_at").defaultNow().notNull()
 });
 const merklePaths = s.table(EnumTableName.MERKLE_PATHS, {
-	offerHash: varchar("offer_hash", { length: 66 }).primaryKey().references(() => offers.hash, { onDelete: "cascade" }),
+	offerHash: varchar("offer_hash", { length: 66 }).notNull(),
+	obligationId: varchar("obligation_id", { length: 66 }).notNull(),
 	treeRoot: varchar("tree_root", { length: 66 }).notNull().references(() => trees.root, { onDelete: "cascade" }),
 	proofNodes: text("proof_nodes").notNull(),
 	createdAt: timestamp("created_at").defaultNow().notNull()
-}, (table) => [index("merkle_paths_tree_root_idx").on(table.treeRoot)]);
+}, (table) => [
+	primaryKey({
+		columns: [table.offerHash, table.obligationId],
+		name: "merkle_paths_pk"
+	}),
+	foreignKey({
+		columns: [table.offerHash, table.obligationId],
+		foreignColumns: [offers.hash, offers.obligationId],
+		name: "merkle_paths_offer_fk"
+	}).onDelete("cascade"),
+	index("merkle_paths_tree_root_idx").on(table.treeRoot)
+]);
+
+//#endregion
+//#region src/indexer/collectors/CollectFunctions/processors/processCollateralSeizures.ts
+/**
+* Parse raw MorphoV2 liquidate logs and compute collateral seizures.
+*
+* Seizures only expose `(obligationId, collateralIndex)` and must be resolved
+* to collateral token addresses before creating transfer rows.
+*
+* @param parameters - The parsed event logs and chain ID.
+* @param parameters.logs - Parsed event logs from MorphoV2.
+* @param parameters.chainId - Chain ID for event attribution.
+* @returns Seizure events pending collateral address resolution.
+*/
+function processCollateralSeizures(parameters) {
+	const { logs, chainId } = parameters;
+	const logger = getLogger();
+	const seizureEvents = [];
+	for (const rawLog of logs) {
+		if (rawLog.blockNumber === null || rawLog.logIndex === null || rawLog.transactionHash === null) {
+			logger.debug({
+				chainId,
+				msg: "Skipping collateral log because it is missing required fields"
+			});
+			continue;
+		}
+		if (rawLog.eventName !== liquidateEvent.name) continue;
+		const args = rawLog.args;
+		if (args?.id === void 0 || args?.borrower === void 0 || args?.seizures === void 0) {
+			logger.debug({
+				chainId,
+				msg: "Skipping Liquidate log for collateral because it is missing required args"
+			});
+			continue;
+		}
+		const baseId = `${rawLog.blockNumber.toString()}-${rawLog.logIndex.toString()}-${chainId}-${rawLog.transactionHash}`;
+		for (let seizureIndex = 0; seizureIndex < args.seizures.length; seizureIndex++) {
+			const seizure = args.seizures[seizureIndex];
+			if (seizure.seized === 0n) continue;
+			seizureEvents.push({
+				id: `${baseId}-collateral-liquidate-${seizureIndex}`,
+				chainId,
+				obligationId: args.id,
+				collateralIndex: Number(seizure.collateralIndex),
+				user: args.borrower,
+				amount: seizure.seized,
+				blockNumber: Number(rawLog.blockNumber)
+			});
+		}
+	}
+	return seizureEvents;
+}
+
+//#endregion
+//#region src/indexer/collectors/CollectFunctions/processors/processCollateralTransfers.ts
+/**
+* Parse raw MorphoV2 logs and compute collateral transfers.
+*
+* A collateral position uses `contract = obligationId` and `asset = collateral token address`.
+* The 5-col PK `(chainId, contract, user, positionTypeId, asset)` distinguishes per-token positions.
+*
+* **SupplyCollateral**: Transfer from zeroAddress to onBehalf (supply)
+* **WithdrawCollateral**: Transfer from onBehalf to zeroAddress (withdrawal)
+*
+* @param parameters - The parsed event logs and chain ID.
+* @param parameters.logs - Parsed event logs from MorphoV2.
+* @param parameters.chainId - Chain ID for event attribution.
+* @returns Collateral transfers from SupplyCollateral/WithdrawCollateral.
+*/
+function processCollateralTransfers(parameters) {
+	const { logs, chainId } = parameters;
+	const logger = getLogger();
+	const transfers = [];
+	for (const rawLog of logs) {
+		if (rawLog.blockNumber === null || rawLog.logIndex === null || rawLog.transactionHash === null) {
+			logger.debug({
+				chainId,
+				msg: "Skipping collateral log because it is missing required fields"
+			});
+			continue;
+		}
+		const eventName = rawLog.eventName;
+		const baseId = `${rawLog.blockNumber.toString()}-${rawLog.logIndex.toString()}-${chainId}-${rawLog.transactionHash}`;
+		if (eventName === supplyCollateralEvent.name) {
+			const args = rawLog.args;
+			if (args?.id === void 0 || args?.collateral === void 0 || args?.assets === void 0 || args?.onBehalf === void 0) {
+				logger.debug({
+					chainId,
+					msg: "Skipping SupplyCollateral log because it is missing required args"
+				});
+				continue;
+			}
+			if (args.assets === 0n) continue;
+			transfers.push(from$8({
+				id: `${baseId}-collateral-supply`,
+				chainId,
+				contract: args.id,
+				from: zeroAddress,
+				to: args.onBehalf,
+				value: args.assets,
+				type: Type.COLLATERAL_OF,
+				asset: args.collateral,
+				blockNumber: Number(rawLog.blockNumber)
+			}));
+			continue;
+		}
+		if (eventName === withdrawCollateralEvent.name) {
+			const args = rawLog.args;
+			if (args?.id === void 0 || args?.collateral === void 0 || args?.assets === void 0 || args?.onBehalf === void 0) {
+				logger.debug({
+					chainId,
+					msg: "Skipping WithdrawCollateral log because it is missing required args"
+				});
+				continue;
+			}
+			if (args.assets === 0n) continue;
+			transfers.push(from$8({
+				id: `${baseId}-collateral-withdraw`,
+				chainId,
+				contract: args.id,
+				from: args.onBehalf,
+				to: zeroAddress,
+				value: args.assets,
+				type: Type.COLLATERAL_OF,
+				asset: args.collateral,
+				blockNumber: Number(rawLog.blockNumber)
+			}));
+		}
+	}
+	return transfers;
+}
 
 //#endregion
-//#region src/indexer/collectors/CollectFunctions/collectConsumedEvents.ts
+//#region src/indexer/collectors/CollectFunctions/processors/processConsumedLogs.ts
 const buildGroupKey = (parameters) => {
 	return `${parameters.chainId}-${parameters.maker.toLowerCase()}-${parameters.group.toLowerCase()}`;
 };
-async function* collectConsumedEvents(parameters) {
+/** Parse raw MorphoV2 logs and produce normalized consumed events.
+* @param parameters - The parsed event logs and chain ID.
+* @param parameters.logs - Parsed event logs from MorphoV2 (Consume and Take events).
+* @param parameters.chainId - Chain ID for event attribution.
+* @returns Flat array of consumed events.
+*/
+function processConsumedLogs(parameters) {
+	const { logs, chainId } = parameters;
+	const logger = getLogger();
+	const consumedEvents = [];
+	for (const rawLog of logs) {
+		if (rawLog.blockNumber === null || rawLog.logIndex === null || rawLog.transactionHash === null) {
+			logger.debug({
+				chainId,
+				msg: "Skipping log because it is missing required fields"
+			});
+			continue;
+		}
+		const eventName = rawLog.eventName;
+		if (eventName === consumedEvent.name) {
+			const consumeArgs = rawLog.args;
+			if (consumeArgs?.user === void 0 || consumeArgs?.group === void 0 || consumeArgs?.amount === void 0) {
+				logger.debug({
+					chainId,
+					msg: "Skipping Consume log because it is missing required args"
+				});
+				continue;
+			}
+			consumedEvents.push({
+				kind: "consume",
+				id: `${rawLog.blockNumber.toString()}-${rawLog.logIndex.toString()}-${chainId}-${rawLog.transactionHash}`,
+				chainId,
+				maker: consumeArgs.user,
+				group: consumeArgs.group,
+				amount: consumeArgs.amount,
+				blockNumber: Number(rawLog.blockNumber)
+			});
+			continue;
+		}
+		if (eventName === takeEvent.name) {
+			const takeArgs = rawLog.args;
+			if (takeArgs?.maker === void 0 || takeArgs?.group === void 0 || takeArgs?.consumed === void 0) {
+				logger.debug({
+					chainId,
+					msg: "Skipping Take log because it is missing required args for consumed"
+				});
+				continue;
+			}
+			consumedEvents.push({
+				kind: "take",
+				id: `${rawLog.blockNumber.toString()}-${rawLog.logIndex.toString()}-${chainId}-${rawLog.transactionHash}`,
+				chainId,
+				maker: takeArgs.maker,
+				group: takeArgs.group,
+				consumed: takeArgs.consumed,
+				blockNumber: Number(rawLog.blockNumber)
+			});
+		}
+	}
+	return consumedEvents;
+}
+
+//#endregion
+//#region src/indexer/collectors/CollectFunctions/processors/processDebtTransfers.ts
+/**
+* Parse raw MorphoV2 logs and compute debt transfers.
+*
+* A debt is modeled as a negative position: borrowing = transfer FROM user TO zeroAddress,
+* repayment = FROM zeroAddress TO user. The contract field is the obligationId.
+*
+* Applies the 4-case Take matrix, Repay, and Liquidate attribution rules:
+*
+* **Take event** — Buyer = maker if offerIsBuy, taker otherwise. Seller = the other.
+* | buyerIsLender | sellerIsBorrower | Buyer transfer               | Seller transfer              |
+* |---------------|------------------|------------------------------|------------------------------|
+* | true          | true             | none                         | from: seller → to: 0x0       |
+* | true          | false            | none                         | none                         |
+* | false         | true             | from: 0x0 → to: buyer        | from: seller → to: 0x0       |
+* | false         | false            | from: 0x0 → to: buyer        | none                         |
+*
+* **Repay**: from: 0x0 → to: onBehalf
+* **Liquidate**: from: 0x0 → to: borrower (value = totalRepaid + badDebt)
+*
+* @param parameters - The parsed event logs and chain ID.
+* @param parameters.logs - Parsed event logs from MorphoV2 (Take, Repay, Liquidate events).
+* @param parameters.chainId - Chain ID for event attribution.
+* @returns Transfer events ready for DB insertion.
+*/
+function processDebtTransfers(parameters) {
+	const { logs, chainId } = parameters;
+	const logger = getLogger();
+	const transfers = [];
+	for (const rawLog of logs) {
+		if (rawLog.blockNumber === null || rawLog.logIndex === null || rawLog.transactionHash === null) {
+			logger.debug({
+				chainId,
+				msg: "Skipping debt log because it is missing required fields"
+			});
+			continue;
+		}
+		const eventName = rawLog.eventName;
+		const baseId = `${rawLog.blockNumber.toString()}-${rawLog.logIndex.toString()}-${chainId}-${rawLog.transactionHash}`;
+		if (eventName === takeEvent.name) {
+			const args = rawLog.args;
+			if (args?.id === void 0 || args?.maker === void 0 || args?.taker === void 0 || args?.offerIsBuy === void 0 || args?.obligationUnits === void 0 || args?.buyerIsLender === void 0 || args?.sellerIsBorrower === void 0) {
+				logger.debug({
+					chainId,
+					msg: "Skipping Take log because it is missing required args for debt"
+				});
+				continue;
+			}
+			if (args.obligationUnits === 0n) continue;
+			const buyer = args.offerIsBuy ? args.maker : args.taker;
+			const seller = args.offerIsBuy ? args.taker : args.maker;
+			const blockNumber = Number(rawLog.blockNumber);
+			if (!args.buyerIsLender) transfers.push(from$8({
+				id: `${baseId}-debt-buyer`,
+				chainId,
+				contract: args.id,
+				from: zeroAddress,
+				to: buyer,
+				value: args.obligationUnits,
+				type: Type.DEBT_OF,
+				asset: zeroAddress,
+				blockNumber
+			}));
+			if (args.sellerIsBorrower) transfers.push(from$8({
+				id: `${baseId}-debt-seller`,
+				chainId,
+				contract: args.id,
+				from: seller,
+				to: zeroAddress,
+				value: args.obligationUnits,
+				type: Type.DEBT_OF,
+				asset: zeroAddress,
+				blockNumber
+			}));
+			continue;
+		}
+		if (eventName === repayEvent.name) {
+			const args = rawLog.args;
+			if (args?.id === void 0 || args?.obligationUnits === void 0 || args?.onBehalf === void 0) {
+				logger.debug({
+					chainId,
+					msg: "Skipping Repay log because it is missing required args"
+				});
+				continue;
+			}
+			if (args.obligationUnits === 0n) continue;
+			transfers.push(from$8({
+				id: `${baseId}-debt-repay`,
+				chainId,
+				contract: args.id,
+				from: zeroAddress,
+				to: args.onBehalf,
+				value: args.obligationUnits,
+				type: Type.DEBT_OF,
+				asset: zeroAddress,
+				blockNumber: Number(rawLog.blockNumber)
+			}));
+			continue;
+		}
+		if (eventName === liquidateEvent.name) {
+			const args = rawLog.args;
+			if (args?.id === void 0 || args?.borrower === void 0 || args?.totalRepaid === void 0 || args?.badDebt === void 0) {
+				logger.debug({
+					chainId,
+					msg: "Skipping Liquidate log because it is missing required args"
+				});
+				continue;
+			}
+			const totalReduction = args.totalRepaid + args.badDebt;
+			if (totalReduction === 0n) continue;
+			transfers.push(from$8({
+				id: `${baseId}-debt-liquidate`,
+				chainId,
+				contract: args.id,
+				from: zeroAddress,
+				to: args.borrower,
+				value: totalReduction,
+				type: Type.DEBT_OF,
+				asset: zeroAddress,
+				blockNumber: Number(rawLog.blockNumber)
+			}));
+		}
+	}
+	return transfers;
+}
+
+//#endregion
+//#region src/indexer/collectors/CollectFunctions/collectMorphoV2.ts
+async function* collectMorphoV2(parameters) {
 	let { db, collector, client, lastBlockNumber: blockNumber, epoch, options: { maxBatchSize = 1e3, blockWindow } = {} } = parameters;
 	const logger = getLogger();
 	let startBlock = blockNumber;
@@ -5786,179 +6395,63 @@ async function* collectConsumedEvents(parameters) {
 	});
 	for await (const { logs, blockNumber: lastStreamBlockNumber } of stream) {
 		const parsedLogs = parseEventLogs({
-			abi: [consumedEvent, takeEvent],
+			abi: [
+				consumedEvent,
+				takeEvent,
+				repayEvent,
+				liquidateEvent,
+				supplyCollateralEvent,
+				withdrawCollateralEvent
+			],
 			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)
-				});
-			}
-		}
+		const consumedEvents = processConsumedLogs({
+			logs: parsedLogs,
+			chainId: client.chain.id
+		});
+		const debtTransfers = processDebtTransfers({
+			logs: parsedLogs,
+			chainId: client.chain.id
+		});
+		const collateralTransfers = processCollateralTransfers({
+			logs: parsedLogs,
+			chainId: client.chain.id
+		});
+		const seizureEvents = processCollateralSeizures({
+			logs: parsedLogs,
+			chainId: client.chain.id
+		});
 		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"
-				});
+			const [resolvedSeizureTransfers, resolvedConsumedEvents] = await Promise.all([resolveSeizureTransfers({
+				dbTx,
+				seizureEvents
+			}), resolveConsumedEvents({
+				dbTx,
+				consumedEvents,
+				chainId: client.chain.id,
+				collector,
+				logger
+			})]);
+			if (debtTransfers.length > 0) {
+				await dbTx.positions.upsert(transfersToPositions(debtTransfers));
+				await dbTx.transfers.create(debtTransfers);
 			}
+			const allCollateralTransfers = [...resolvedSeizureTransfers, ...collateralTransfers];
+			if (allCollateralTransfers.length > 0) {
+				await dbTx.positions.upsert(transfersToPositions(allCollateralTransfers));
+				await dbTx.transfers.create(allCollateralTransfers);
+			}
+			await dbTx.consumed.create(resolvedConsumedEvents);
+			if (resolvedConsumedEvents.length > 0) logger.info({
+				msg: "Events indexed",
+				collector,
+				consumed_count: resolvedConsumedEvents.length,
+				debt_transfer_count: debtTransfers.length,
+				collateral_transfer_count: allCollateralTransfers.length,
+				chain_id: client.chain.id,
+				block_range: [startBlock, lastStreamBlockNumber]
+			});
 			blockNumber = lastStreamBlockNumber;
 			try {
 				await dbTx.blocks.advanceCollector({
@@ -5974,15 +6467,27 @@ async function* collectConsumedEvents(parameters) {
 						chainId: client.chain.id
 					});
 					blockNumber = ancestor.blockNumber;
-					const deleted = await dbTx.consumed.delete({
+					const deletedConsumed = await dbTx.consumed.delete({
 						chainId: client.chain.id,
 						blockNumberGte: blockNumber + 1
 					});
+					const deletedDebtTransfers = await dbTx.transfers.delete({
+						chainId: client.chain.id,
+						blockNumberGte: blockNumber + 1,
+						positionTypeId: positionTypeId(Type.DEBT_OF)
+					});
+					const deletedCollateralTransfers = await dbTx.transfers.delete({
+						chainId: client.chain.id,
+						blockNumberGte: blockNumber + 1,
+						positionTypeId: positionTypeId(Type.COLLATERAL_OF)
+					});
 					logger.info({
 						collector,
 						chain_id: client.chain.id,
-						msg: `Reorg detected, events deleted`,
-						count: deleted,
+						msg: "Reorg detected, events deleted",
+						consumed_deleted: deletedConsumed,
+						debt_transfers_deleted: deletedDebtTransfers,
+						collateral_transfers_deleted: deletedCollateralTransfers,
 						block_number: blockNumber
 					});
 					await dbTx.blocks.advanceCollector({
@@ -5993,7 +6498,7 @@ async function* collectConsumedEvents(parameters) {
 					});
 					reorgDetected = true;
 				} catch (err) {
-					const msg = "Failed to delete consumed events when handling reorg.";
+					const msg = "Failed to delete events when handling reorg.";
 					logger.error({
 						collector,
 						chainId: client.chain.id,
@@ -6008,10 +6513,210 @@ async function* collectConsumedEvents(parameters) {
 		yield blockNumber;
 		startBlock = blockNumber;
 	}
+	if (!reorgDetected) await db.transaction(async (dbTx) => {
+		const collectorState = await dbTx.blocks.getCollector({
+			collectorName: collector,
+			chainId: client.chain.id
+		});
+		const deletedConsumed = await dbTx.consumed.delete({
+			chainId: client.chain.id,
+			blockNumberGte: collectorState.blockNumber + 1
+		});
+		const deletedDebtTransfers = await dbTx.transfers.delete({
+			chainId: client.chain.id,
+			blockNumberGte: collectorState.blockNumber + 1,
+			positionTypeId: positionTypeId(Type.DEBT_OF)
+		});
+		const deletedCollateralTransfers = await dbTx.transfers.delete({
+			chainId: client.chain.id,
+			blockNumberGte: collectorState.blockNumber + 1,
+			positionTypeId: positionTypeId(Type.COLLATERAL_OF)
+		});
+		if (deletedConsumed > 0 || deletedDebtTransfers > 0 || deletedCollateralTransfers > 0) logger.info({
+			collector,
+			chain_id: client.chain.id,
+			msg: "Reorg detected, events deleted",
+			consumed_deleted: deletedConsumed,
+			debt_transfers_deleted: deletedDebtTransfers,
+			collateral_transfers_deleted: deletedCollateralTransfers,
+			block_number: collectorState.blockNumber
+		});
+	});
+}
+async function resolveSeizureTransfers(parameters) {
+	const { dbTx, seizureEvents } = parameters;
+	if (seizureEvents.length === 0) return [];
+	const uniqueObligationIds = [...new Set(seizureEvents.map((event) => event.obligationId.toLowerCase()))];
+	const rows = await dbTx.select({
+		obligationId: obligationIdKeys.obligationId,
+		collateralIndex: obligationCollateralsV2.collateralIndex,
+		asset: obligationCollateralsV2.asset
+	}).from(obligationIdKeys).innerJoin(obligationCollateralsV2, eq(obligationIdKeys.obligationKey, obligationCollateralsV2.obligationKey)).where(inArray(obligationIdKeys.obligationId, uniqueObligationIds));
+	const resolutionMap = /* @__PURE__ */ new Map();
+	for (const row of rows) resolutionMap.set(`${row.obligationId.toLowerCase()}-${row.collateralIndex}`, row.asset);
+	const resolvedSeizureTransfers = [];
+	for (const seizure of seizureEvents) {
+		const key = `${seizure.obligationId.toLowerCase()}-${seizure.collateralIndex}`;
+		const asset = resolutionMap.get(key);
+		if (asset === void 0) throw new Error(`Unresolvable Liquidate seizure: obligationId=${seizure.obligationId}, collateralIndex=${seizure.collateralIndex}, chainId=${seizure.chainId}, blockNumber=${seizure.blockNumber}`);
+		resolvedSeizureTransfers.push(from$8({
+			id: seizure.id,
+			chainId: seizure.chainId,
+			contract: seizure.obligationId,
+			from: seizure.user,
+			to: zeroAddress,
+			value: seizure.amount,
+			type: Type.COLLATERAL_OF,
+			asset,
+			blockNumber: seizure.blockNumber
+		}));
+	}
+	return resolvedSeizureTransfers;
+}
+async function resolveConsumedEvents(parameters) {
+	const { dbTx, consumedEvents, chainId, collector, logger } = parameters;
+	if (consumedEvents.length === 0) return [];
+	const [existingConsumedIds, consumedByGroup] = await Promise.all([getExistingConsumedIds({
+		dbTx,
+		consumedEvents
+	}), getConsumedByGroup({
+		dbTx,
+		consumedEvents
+	})]);
+	const resolvedEvents = [];
+	for (const log of consumedEvents) {
+		if (existingConsumedIds.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") {
+			resolvedEvents.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,
+				msg: "Skipping Take log because consumed did not increase",
+				previous_consumed: previousConsumed.toString(),
+				consumed: log.consumed.toString()
+			});
+			continue;
+		}
+		resolvedEvents.push({
+			id: log.id,
+			chainId: log.chainId,
+			maker: log.maker,
+			group: log.group,
+			amount: delta,
+			blockNumber: log.blockNumber
+		});
+		consumedByGroup.set(groupKey, log.consumed);
+	}
+	return resolvedEvents;
+}
+async function getExistingConsumedIds(parameters) {
+	const { dbTx, consumedEvents: consumedEvents$1 } = parameters;
+	const existingConsumedIds = /* @__PURE__ */ new Set();
+	const ids = Array.from(new Set(consumedEvents$1.map((event) => event.id)));
+	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) existingConsumedIds.add(row.event_id);
+	}
+	return existingConsumedIds;
+}
+async function getConsumedByGroup(parameters) {
+	const { dbTx, consumedEvents } = parameters;
+	const groups$3 = /* @__PURE__ */ new Map();
+	for (const event of consumedEvents) {
+		const key = buildGroupKey({
+			chainId: event.chainId,
+			maker: event.maker,
+			group: event.group
+		});
+		if (!groups$3.has(key)) groups$3.set(key, {
+			chainId: event.chainId,
+			maker: event.maker,
+			group: event.group
+		});
+	}
+	const consumedByGroup = /* @__PURE__ */ new Map();
+	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"));
+		}
+	}
+	return consumedByGroup;
+}
+function transfersToPositions(transfers) {
+	if (transfers.length === 0) return [];
+	const transferType = transfers[0].type;
+	if (transfers.some((transfer) => transfer.type !== transferType)) throw new Error("Cannot map transfers with mixed position types to positions.");
+	const positionKeys = /* @__PURE__ */ new Map();
+	for (const transfer of transfers) for (const user of [transfer.from, transfer.to]) {
+		const key = `${transfer.chainId}-${transfer.contract}-${user}-${transfer.asset}`.toLowerCase();
+		const existing = positionKeys.get(key);
+		if (!existing || transfer.blockNumber < existing.blockNumber) positionKeys.set(key, {
+			chainId: transfer.chainId,
+			contract: transfer.contract,
+			user,
+			asset: transfer.asset,
+			blockNumber: transfer.blockNumber
+		});
+	}
+	return Array.from(positionKeys.values()).map((position) => from$10({
+		chainId: position.chainId,
+		contract: position.contract,
+		user: position.user,
+		type: transferType,
+		balance: 0n,
+		asset: position.asset,
+		blockNumber: position.blockNumber
+	}));
 }
 
 //#endregion
 //#region src/indexer/collectors/CollectFunctions/collectOffers.ts
+const ERC20_TYPE_ID = Object.values(Type).indexOf(Type.ERC20) + 1;
 async function* collectOffersV2(parameters) {
 	let { db, collector, client, lastBlockNumber: blockNumber, gatekeeper, options: { maxBatchSize = 1e3, blockWindow } = {} } = parameters;
 	const logger = getLogger();
@@ -6025,9 +6730,10 @@ async function* collectOffersV2(parameters) {
 		});
 		throw new Error(msg);
 	}
+	const morphoV2 = client.chain.custom.morpho.address;
 	const signatureDomain = {
 		chainId: client.chain.id,
-		verifyingContract: client.chain.custom.morpho.address
+		verifyingContract: morphoV2
 	};
 	const { blockNumber: latestBlockNumberChain } = await db.blocks.getChain(client.chain.id);
 	const stream = streamLogs({
@@ -6090,10 +6796,14 @@ async function* collectOffersV2(parameters) {
 		await db.transaction(async (dbTx) => {
 			const { epoch, blockNumber: latestBlockNumber } = await dbTx.blocks.getChain(client.chain.id);
 			const treesToInsert = [];
+			const pathsToInsert = [];
 			let totalValidOffers = 0;
 			const offersWithBlock = [];
 			for (const { tree, signature, blockNumber: treeBlockNumber } of decodedTrees) try {
-				const allowedResults = await gatekeeper.isAllowed(tree.offers);
+				const allowedResults = await gatekeeper.isAllowed({
+					offers: tree.offers,
+					chainId: client.chain.id
+				});
 				const hasBlockWindowViolation = treeBlockNumber > latestBlockNumber;
 				if (!(allowedResults.issues.length === 0 && allowedResults.valid.length === tree.offers.length) || hasBlockWindowViolation) {
 					if (allowedResults.issues.length > 0) {
@@ -6112,14 +6822,35 @@ async function* collectOffersV2(parameters) {
 					continue;
 				}
 				treesToInsert.push({
-					tree,
+					root: tree.root,
 					signature
 				});
 				totalValidOffers += tree.offers.length;
-				offersWithBlock.push(...tree.offers.map((offer) => ({
-					offer,
-					blockNumber: treeBlockNumber
-				})));
+				const obligationIdsByOfferHash = /* @__PURE__ */ new Map();
+				for (const offer of tree.offers) {
+					const offerHash = hash(offer).toLowerCase();
+					const obligationId$3 = obligationId(offer, {
+						chainId: client.chain.id,
+						morphoV2
+					}).toLowerCase();
+					offersWithBlock.push({
+						offer,
+						blockNumber: treeBlockNumber,
+						obligationId: obligationId$3
+					});
+					obligationIdsByOfferHash.set(offerHash, obligationId$3);
+				}
+				for (const proof of proofs(tree)) {
+					const offerHash = hash(proof.offer).toLowerCase();
+					const obligationId = obligationIdsByOfferHash.get(offerHash);
+					if (obligationId === void 0) continue;
+					pathsToInsert.push({
+						offerHash,
+						obligationId,
+						treeRoot: tree.root,
+						proof: proof.path
+					});
+				}
 			} catch (err) {
 				const error = err instanceof Error ? err : new Error(String(err));
 				logger.error({
@@ -6129,19 +6860,23 @@ async function* collectOffersV2(parameters) {
 				});
 				throw new Error("Gatekeeper validation failed", { cause: error });
 			}
-			const dependencies = buildOfferDependencies$1(offersWithBlock);
+			const dependencies = buildOfferDependencies$1({
+				offers: offersWithBlock,
+				chainId: client.chain.id,
+				morphoV2
+			});
 			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 insertedReferences = await dbTx.offers.create(dependencies.offerBatches);
+			if (treesToInsert.length > 0) await dbTx.trees.upsert(treesToInsert);
+			if (pathsToInsert.length > 0) await dbTx.trees.upsertPaths(pathsToInsert);
 			const { callbacks, positions, lots } = decodeCallbacks({
-				chainId: client.chain.id,
-				offers: insertedOffers
+				offers: filterInsertedOffers({
+					offers: offersWithBlock,
+					references: insertedReferences
+				}),
+				chainId: client.chain.id
 			});
 			if (positions.length > 0) await dbTx.positions.upsert(positions);
 			if (callbacks.length > 0) await dbTx.callbacks.upsert(callbacks);
@@ -6204,7 +6939,7 @@ async function* collectOffersV2(parameters) {
 	}
 }
 function decodeCallbacks(parameters) {
-	const { offers } = parameters;
+	const { offers, chainId } = parameters;
 	if (offers.length === 0) return {
 		callbacks: [],
 		positions: [],
@@ -6213,12 +6948,12 @@ function decodeCallbacks(parameters) {
 	const callbacks = [];
 	const positions = [];
 	const lots = [];
-	for (const { offer, blockNumber: offerBlockNumber } of offers) {
+	for (const { offer, blockNumber: offerBlockNumber, obligationId } of offers) {
 		if (!offer.buy) continue;
 		if (!isEmptyCallback(offer)) continue;
 		const loanToken = offer.loanToken.toLowerCase();
 		positions.push(from$10({
-			chainId: offer.chainId,
+			chainId,
 			contract: loanToken,
 			user: offer.maker,
 			type: Type.ERC20,
@@ -6226,20 +6961,23 @@ function decodeCallbacks(parameters) {
 			blockNumber: offerBlockNumber
 		}));
 		lots.push({
-			positionChainId: offer.chainId,
+			positionChainId: chainId,
 			positionContract: loanToken,
 			positionUser: offer.maker,
+			positionTypeId: ERC20_TYPE_ID,
 			group: offer.group,
-			obligationId: obligationId(offer),
+			obligationId,
 			size: offer.assets
 		});
 		callbacks.push({
 			offerHash: hash(offer),
+			obligationId,
 			callbacks: [{
-				chainId: offer.chainId,
+				chainId,
 				contract: loanToken,
 				user: offer.maker,
-				amount: offer.assets
+				amount: offer.assets,
+				positionTypeId: ERC20_TYPE_ID
 			}]
 		});
 	}
@@ -6249,34 +6987,42 @@ function decodeCallbacks(parameters) {
 		lots
 	};
 }
-function buildOfferDependencies$1(offers) {
+function buildOfferDependencies$1(parameters) {
+	const { offers, chainId, morphoV2 } = parameters;
 	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) {
+	for (const { offer, blockNumber, obligationId } of offers) {
 		const list = offersByBlock.get(blockNumber) ?? [];
-		list.push(offer);
+		list.push({
+			offer,
+			obligationId,
+			chainId
+		});
 		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
-		}));
+		if (!obligationsById.get(obligationId)) obligationsById.set(obligationId, {
+			obligationId,
+			chainId,
+			morphoV2,
+			obligation: from$13({
+				loanToken: offer.loanToken,
+				maturity: offer.maturity,
+				collaterals: offer.collaterals
+			})
+		});
 		for (const collateral of offer.collaterals) {
-			const oracleKey = `${offer.chainId}-${collateral.oracle}`.toLowerCase();
+			const oracleKey = `${chainId}-${collateral.oracle}`.toLowerCase();
 			if (!oraclesByKey.has(oracleKey)) oraclesByKey.set(oracleKey, from$11({
-				chainId: offer.chainId,
+				chainId,
 				address: collateral.oracle,
 				price: null,
 				blockNumber
 			}));
 		}
-		const groupKey = `${offer.chainId}-${offer.maker}-${offer.group}`.toLowerCase();
+		const groupKey = `${chainId}-${offer.maker}-${offer.group}`.toLowerCase();
 		if (!groupsByKey.has(groupKey)) groupsByKey.set(groupKey, {
-			chainId: offer.chainId,
+			chainId,
 			maker: offer.maker,
 			group: offer.group,
 			blockNumber
@@ -6293,15 +7039,22 @@ function buildOfferDependencies$1(offers) {
 	};
 }
 function filterInsertedOffers(parameters) {
-	if (parameters.hashes.length === 0) return [];
-	const inserted = new Set(parameters.hashes.map((hash) => hash.toLowerCase()));
+	if (parameters.references.length === 0) return [];
+	const keyOf = (input) => `${input.hash.toLowerCase()}:${input.obligationId.toLowerCase()}`;
+	const inserted = new Set(parameters.references.map((offer) => keyOf({
+		hash: offer.hash,
+		obligationId: offer.obligationId
+	})));
 	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);
+		const key = keyOf({
+			hash: hash(entry.offer),
+			obligationId: entry.obligationId
+		});
+		if (!inserted.has(key)) continue;
+		if (seen.has(key)) continue;
+		seen.add(key);
 		filtered.push(entry);
 	}
 	return filtered;
@@ -6416,7 +7169,7 @@ async function snapshotVaultPositions(parameters) {
 			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;
+				if (contract.decimalsOffset === void 0 || contract.totalAssets === void 0 || contract.totalSupply === void 0 || contract.asset === void 0) return;
 				try {
 					position.balance = convertToAssets({
 						shares,
@@ -6571,12 +7324,15 @@ async function* collectPositions(parameters) {
 				from: log.args.from,
 				to: log.args.to,
 				value: log.args.value,
+				type: Type.ERC20,
+				asset: log.address,
 				blockNumber: Number(log.blockNumber)
 			}));
 		}
 		const { positions } = await db.positions.get({
 			chainId: client.chain.id,
-			filled: false
+			filled: false,
+			type: Type.ERC20
 		});
 		const newPositions = [];
 		try {
@@ -6699,7 +7455,8 @@ async function* collectPositions(parameters) {
 				blockNumber = ancestor.blockNumber;
 				const emptied = await dbTx.positions.setEmptyAfter({
 					chainId: client.chain.id,
-					blockNumber: blockNumber + 1
+					blockNumber: blockNumber + 1,
+					type: Type.ERC20
 				});
 				logger.info({
 					msg: "Reorg detected, positions set to empty",
@@ -6926,10 +7683,10 @@ function createBuilder(parameters) {
 				}
 			}));
 		},
-		buildConsumedEventsCollector: ({ options: { maxBatchSize = 1e3 } = {} } = {}) => {
-			return createCollector("consumed_events", (p) => collectConsumedEvents({
+		buildMorphoV2Collector: ({ options: { maxBatchSize = 1e3 } = {} } = {}) => {
+			return createCollector("morpho_v2", (p) => collectMorphoV2({
 				...p,
-				collector: "consumed_events",
+				collector: "morpho_v2",
 				options: {
 					maxBatchSize,
 					blockWindow
@@ -6978,7 +7735,7 @@ const from$2 = (parameters) => {
 	});
 	return {
 		offersCollector: collectorBuilder.buildOffersCollector({ options: { maxBatchSize } }),
-		consumedEventsCollector: collectorBuilder.buildConsumedEventsCollector({ options: { maxBatchSize } }),
+		morphoV2Collector: collectorBuilder.buildMorphoV2Collector({ options: { maxBatchSize } }),
 		pricesCollector: collectorBuilder.buildPricesCollector({ options: {
 			maxBatchSize,
 			retryAttempts,
@@ -6996,7 +7753,7 @@ const from$2 = (parameters) => {
 //#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({
+	const { offersCollector, morphoV2Collector, positionsCollector, pricesCollector } = from$2({
 		client,
 		db,
 		gatekeeper,
@@ -7011,7 +7768,7 @@ function from$1(config) {
 		client,
 		collectors: [
 			offersCollector,
-			consumedEventsCollector,
+			morphoV2Collector,
 			positionsCollector,
 			pricesCollector
 		]
@@ -7282,7 +8039,7 @@ const reconcile = async (parameters) => {
 //#region src/indexer/collectors/Collector.ts
 const names = [
 	"offers",
-	"consumed_events",
+	"morpho_v2",
 	"positions",
 	"prices"
 ];
@@ -7681,18 +8438,17 @@ async function _getOffers(db, params) {
 	const { obligationId, side, now, priceSortDirection, cursor, limit } = params;
 	const raw = await db.execute(sql`
     WITH collats AS MATERIALIZED (
-      SELECT oc.obligation_id,
+      SELECT oia.obligation_id,
             COALESCE(jsonb_agg(jsonb_build_object(
               'asset',  oc.asset,
-              'oracle', oracle.address,
+              'oracle', oc.oracle_address,
               'lltv',   oc.lltv
             ) ORDER BY oc.asset), '[]'::jsonb) AS collaterals
-      FROM ${obligationCollateralsV2} oc
-      JOIN ${oracles} oracle
-        ON oracle.chain_id = oc.oracle_chain_id
-        AND oracle.address  = oc.oracle_address
-      WHERE oc.obligation_id = ${obligationId}
-      GROUP BY oc.obligation_id
+      FROM ${obligationIdKeys} oia
+      JOIN ${obligationCollateralsV2} oc
+        ON oc.obligation_key = oia.obligation_key
+      WHERE oia.obligation_id = ${obligationId}
+      GROUP BY oia.obligation_id
     ),
     winners AS (
       SELECT DISTINCT ON (o.group_chain_id, o.group_maker, o."group_group")
@@ -7700,6 +8456,7 @@ async function _getOffers(db, params) {
       FROM ${offers} o
       LEFT JOIN ${validations} v
         ON v.offer_hash = o.hash
+        AND v.obligation_id = o.obligation_id
       LEFT JOIN ${status} s
         ON s.id = v.status_id
       WHERE o.obligation_id = ${obligationId}
@@ -7726,8 +8483,10 @@ async function _getOffers(db, params) {
         ON g.chain_id = w.group_chain_id
         AND g.maker    = w.group_maker
         AND g."group"  = w."group_group"
+      JOIN ${obligationIdKeys} oia
+        ON oia.obligation_id = w.obligation_id
       JOIN ${obligations} obl
-        ON obl.obligation_id = w.obligation_id
+        ON obl.obligation_key = oia.obligation_key
     ),
     paged AS (
       SELECT e.*
@@ -7826,7 +8585,9 @@ async function _getOffers(db, params) {
             END
         )) AS lot_balance
       FROM paged p
-      LEFT JOIN ${offersCallbacks} oc ON oc.offer_hash = p.hash
+      LEFT JOIN ${offersCallbacks} oc
+        ON oc.offer_hash = p.hash
+        AND oc.obligation_id = p.obligation_id
       LEFT JOIN ${callbacks} c ON c.id = oc.callback_id
       LEFT JOIN ${lots} l
         ON l.chain_id = c.position_chain_id
@@ -7911,11 +8672,13 @@ async function _getOffers(db, params) {
         AND NOT EXISTS (
           SELECT 1 FROM ${offersCallbacks} oc2
           WHERE oc2.offer_hash = p.hash
+            AND oc2.obligation_id = p.obligation_id
         )
     )
     -- Final SELECT with inline takeable computation
     SELECT
       oc.hash,
+      oc.obligation_id,
       oc.group_maker,
       oc.assets,
       oc.obligation_units,
@@ -7964,6 +8727,7 @@ async function _getOffers(db, params) {
 			const receiverIfMakerIsSeller = (row.receiver_if_maker_is_seller ?? row.group_maker).toLowerCase();
 			return {
 				hash: row.hash,
+				obligationId: row.obligation_id,
 				maker: row.group_maker,
 				assets: BigInt(row.assets),
 				obligationUnits: BigInt(row.obligation_units ?? 0),
@@ -8092,18 +8856,21 @@ function create$14(db) {
 				idCache.set(preimage, id);
 				return id;
 			};
-			for (const { offerHash, callbacks } of inputs) {
+			for (const { offerHash, obligationId, callbacks } of inputs) {
 				const normalizedOfferHash = offerHash.toLowerCase();
+				const normalizedObligationId = obligationId.toLowerCase();
 				for (const callback of callbacks) {
 					const normalized = {
 						chainId: callback.chainId,
 						contract: callback.contract.toLowerCase(),
 						user: callback.user.toLowerCase(),
-						amount: callback.amount
+						amount: callback.amount,
+						positionTypeId: callback.positionTypeId
 					};
 					const id = callbackId(normalized);
 					offersCallbacksRows.push({
 						offerHash: normalizedOfferHash,
+						obligationId: normalizedObligationId,
 						callbackId: id
 					});
 					if (seenCallbackIds.has(id)) continue;
@@ -8113,6 +8880,7 @@ function create$14(db) {
 						positionChainId: normalized.chainId,
 						positionContract: normalized.contract,
 						positionUser: normalized.user,
+						positionTypeId: normalized.positionTypeId,
 						amount: normalized.amount.toString()
 					});
 				}
@@ -8225,6 +8993,17 @@ function create$11(db) {
 				const existing = lotsByKey.get(key);
 				if (!existing || offer.size > existing.size) lotsByKey.set(key, offer);
 			}
+			const positionsByKey = /* @__PURE__ */ new Map();
+			for (const offer of lotsByKey.values()) {
+				const posKey = `${offer.positionChainId}-${offer.positionContract}-${offer.positionUser}`.toLowerCase();
+				if (!positionsByKey.has(posKey)) positionsByKey.set(posKey, {
+					chainId: offer.positionChainId,
+					contract: offer.positionContract.toLowerCase(),
+					user: offer.positionUser.toLowerCase(),
+					positionTypeId: offer.positionTypeId
+				});
+			}
+			for (const row of positionsByKey.values()) await db.insert(lotsPositions).values(row).onConflictDoNothing();
 			for (const offer of lotsByKey.values()) if ((await db.select().from(lots).where(and(eq(lots.chainId, offer.positionChainId), eq(lots.contract, offer.positionContract.toLowerCase()), eq(lots.user, offer.positionUser.toLowerCase()), eq(lots.group, offer.group.toLowerCase()), eq(lots.obligationId, offer.obligationId.toLowerCase()))).limit(1)).length === 0) {
 				const maxUpperResult = await db.select({ maxUpper: sql`COALESCE(MAX(${lots.upper}::numeric), 0)` }).from(lots).where(and(eq(lots.chainId, offer.positionChainId), eq(lots.contract, offer.positionContract.toLowerCase()), eq(lots.user, offer.positionUser.toLowerCase()), eq(lots.obligationId, offer.obligationId.toLowerCase())));
 				const newLower = BigInt(maxUpperResult[0]?.maxUpper ?? "0");
@@ -8256,52 +9035,66 @@ function create$10(db) {
 			const chainIds = parameters?.chainId;
 			const now$3 = now();
 			return (await db.select({
-				chainId: obligations.chainId,
+				obligationId: obligationIdKeys.obligationId,
+				chainId: obligationIdKeys.chainId,
+				morphoV2: obligationIdKeys.morphoV2,
 				loanToken: obligations.loanToken,
-				collaterals: sql`ARRAY_AGG(jsonb_build_object('asset', ${obligationCollateralsV2.asset}, 'oracle', ${oracles.address}, 'lltv', ${obligationCollateralsV2.lltv}))`.as("collaterals"),
+				collaterals: sql`ARRAY_AGG(jsonb_build_object('asset', ${obligationCollateralsV2.asset}, 'oracle', ${obligationCollateralsV2.oracleAddress}, 'lltv', ${obligationCollateralsV2.lltv}))`.as("collaterals"),
 				maturity: obligations.maturity
-			}).from(obligations).innerJoin(obligationCollateralsV2, eq(obligations.obligationId, obligationCollateralsV2.obligationId)).innerJoin(oracles, sql`${obligationCollateralsV2.oracleChainId} = ${oracles.chainId}
-             AND ${obligationCollateralsV2.oracleAddress} = ${oracles.address}`).groupBy(obligations.obligationId).where(and(chainIds !== void 0 && chainIds.length > 0 ? inArray(obligations.chainId, chainIds) : void 0, gte(obligations.maturity, now$3))).orderBy(asc(obligations.obligationId))).map((row) => from$13({
+			}).from(obligationIdKeys).innerJoin(obligations, eq(obligationIdKeys.obligationKey, obligations.obligationKey)).innerJoin(obligationCollateralsV2, eq(obligations.obligationKey, obligationCollateralsV2.obligationKey)).groupBy(obligationIdKeys.obligationId, obligationIdKeys.chainId, obligationIdKeys.morphoV2, obligations.loanToken, obligations.maturity).where(and(chainIds !== void 0 && chainIds.length > 0 ? inArray(obligationIdKeys.chainId, chainIds) : void 0, gte(obligations.maturity, now$3))).orderBy(asc(obligationIdKeys.obligationId))).map((row) => ({
+				obligationId: row.obligationId,
 				chainId: row.chainId,
-				loanToken: row.loanToken,
-				collaterals: row.collaterals.sort((left, right) => left.asset.localeCompare(right.asset)).map((collateral) => from$14({
-					asset: collateral.asset,
-					oracle: collateral.oracle,
-					lltv: from$15(BigInt(collateral.lltv))
-				})),
-				maturity: row.maturity
+				morphoV2: row.morphoV2,
+				obligation: from$13({
+					loanToken: row.loanToken,
+					collaterals: row.collaterals.sort((left, right) => left.asset.localeCompare(right.asset)).map((collateral) => from$14({
+						asset: collateral.asset,
+						oracle: collateral.oracle,
+						lltv: from$15(BigInt(collateral.lltv))
+					})),
+					maturity: row.maturity
+				})
 			}));
 		},
 		create: async (obligations$1) => {
 			if (obligations$1.length === 0) return;
-			const obligationsById = /* @__PURE__ */ new Map();
-			for (const obligation of obligations$1) {
-				const id$1 = id(obligation).toLowerCase();
-				if (!obligationsById.get(id$1)) obligationsById.set(id$1, obligation);
+			const obligationsByKey = /* @__PURE__ */ new Map();
+			const obligationIdKeysById = /* @__PURE__ */ new Map();
+			for (const input of obligations$1) {
+				const obligationKey = key(input.obligation).toLowerCase();
+				if (!obligationsByKey.has(obligationKey)) obligationsByKey.set(obligationKey, input.obligation);
+				const obligationId = input.obligationId.toLowerCase();
+				if (!obligationIdKeysById.has(obligationId)) obligationIdKeysById.set(obligationId, input);
 			}
 			try {
 				await db.transaction(async (dbTx) => {
-					const obligationRows = obligations$1.map((obligation) => ({
-						obligationId: id(obligation),
-						chainId: obligation.chainId,
-						loanToken: obligation.loanToken.toLowerCase(),
-						maturity: obligation.maturity
+					const obligationRows = Array.from(obligationsByKey.entries()).map(([obligationKey, item]) => ({
+						obligationKey,
+						loanToken: item.loanToken.toLowerCase(),
+						maturity: item.maturity
 					}));
 					for (const batch of batch$1(obligationRows, DEFAULT_BATCH_SIZE)) await dbTx.insert(obligations).values(batch).onConflictDoNothing();
-					const collateralRows = obligations$1.flatMap((obligation) => {
-						return obligation.collaterals.map((collateral) => ({
-							obligationId: id(obligation),
+					const obligationIdKeyRows = Array.from(obligationIdKeysById.entries()).map(([obligationId, input]) => ({
+						obligationId,
+						obligationKey: key(input.obligation).toLowerCase(),
+						chainId: input.chainId,
+						morphoV2: input.morphoV2.toLowerCase()
+					}));
+					for (const batch of batch$1(obligationIdKeyRows, DEFAULT_BATCH_SIZE)) await dbTx.insert(obligationIdKeys).values(batch).onConflictDoNothing();
+					const collateralRows = Array.from(obligationsByKey.entries()).flatMap(([obligationKey, item]) => {
+						return [...item.collaterals].sort((a, b) => a.asset.toLowerCase().localeCompare(b.asset.toLowerCase())).map((collateral, collateralIndex) => ({
+							obligationKey,
 							asset: collateral.asset.toLowerCase(),
-							oracleChainId: obligation.chainId,
 							oracleAddress: collateral.oracle.toLowerCase(),
-							lltv: collateral.lltv
+							lltv: collateral.lltv,
+							collateralIndex
 						}));
 					});
 					for (const batch of batch$1(collateralRows, DEFAULT_BATCH_SIZE)) await dbTx.insert(obligationCollateralsV2).values(batch).onConflictDoNothing();
 				});
 			} catch (err) {
 				const error = err instanceof Error ? err : new Error(String(err));
-				throw new Error("Obligations.create failed. Ensure oracles exist before inserting obligations.", { cause: error });
+				throw new Error("Obligations.create failed. Ensure obligation id keys are valid before inserting offers.", { cause: error });
 			}
 		}
 	};
@@ -8315,10 +9108,10 @@ function create$9(config) {
 	return {
 		create: async (batches) => {
 			if (batches.length === 0) return [];
-			const offersRows = batches.flatMap(({ blockNumber, offers }) => offers.map((offer) => ({
+			const offersRows = batches.flatMap(({ blockNumber, offers }) => offers.map(({ offer, obligationId, chainId }) => ({
 				...serialize(offer),
-				obligationId: obligationId(offer),
-				groupChainId: offer.chainId,
+				obligationId: obligationId.toLowerCase(),
+				groupChainId: chainId,
 				groupMaker: offer.maker.toLowerCase(),
 				callbackAddress: offer.callback.address.toLowerCase(),
 				callbackData: offer.callback.data,
@@ -8328,48 +9121,67 @@ function create$9(config) {
 			if (offersRows.length === 0) return [];
 			try {
 				return await db.transaction(async (dbTx) => {
-					const selectExisting = async (hashes) => {
-						if (hashes.length === 0) return /* @__PURE__ */ new Set();
+					const keyOf = (input) => `${input.hash.toLowerCase()}:${input.obligationId.toLowerCase()}`;
+					const selectExisting = async (offers$1) => {
+						if (offers$1.length === 0) return /* @__PURE__ */ new Set();
+						const expected = new Set(offers$1.map((offer) => keyOf({
+							hash: offer.hash,
+							obligationId: offer.obligationId
+						})));
 						const existing = /* @__PURE__ */ new Set();
+						const hashes = [...new Set(offers$1.map((offer) => offer.hash.toLowerCase()))];
 						for (const batch of batch$1(hashes, DEFAULT_BATCH_SIZE)) {
-							const rows = await dbTx.select({ hash: offers.hash }).from(offers).where(inArray(offers.hash, batch));
-							for (const row of rows) existing.add(String(row.hash).toLowerCase());
+							const rows = await dbTx.select({
+								hash: offers.hash,
+								obligationId: offers.obligationId
+							}).from(offers).where(inArray(offers.hash, batch));
+							for (const row of rows) {
+								const key = keyOf({
+									hash: String(row.hash),
+									obligationId: String(row.obligationId)
+								});
+								if (expected.has(key)) existing.add(key);
+							}
 						}
 						return existing;
 					};
 					const inserted = [];
 					for (const batch of batch$1(offersRows, DEFAULT_BATCH_SIZE)) {
 						const rows = await dbTx.insert(offers).values(batch).onConflictDoNothing().returning();
-						inserted.push(...rows.map((row) => row.hash));
+						inserted.push(...rows.map((row) => ({
+							hash: row.hash,
+							obligationId: row.obligationId
+						})));
 					}
 					const existing = await selectExisting(inserted);
-					return inserted.filter((hash) => existing.has(hash));
+					return inserted.filter((offer) => existing.has(keyOf({
+						hash: offer.hash,
+						obligationId: offer.obligationId
+					})));
 				});
 			} catch (err) {
 				const error = err instanceof Error ? err : new Error(String(err));
-				throw new Error("Offers.create failed. Ensure obligations and groups exist before inserting offers.", { cause: error });
+				throw new Error("Offers.create failed. Ensure obligation id keys and groups exist before inserting offers.", { cause: error });
 			}
 		},
 		get: async (parameters) => {
 			const limit = parameters?.limit ?? DEFAULT_LIMIT$3;
-			const cursor = parameters?.cursor;
+			const rawCursor = parameters?.cursor;
 			const maker = parameters?.maker;
-			if (cursor !== null && cursor !== void 0) {
-				if (!cursor.startsWith("0x") || cursor.length !== 66) throw new Error("Invalid cursor format");
-			}
+			const cursor = rawCursor !== null && rawCursor !== void 0 ? parseCursor$2(rawCursor) : void 0;
 			const collateralsLateral = db.select({ collaterals: sql`COALESCE(
         jsonb_agg(
           jsonb_build_object(
             'asset', ${obligationCollateralsV2.asset},
-            'oracle', ${oracles.address},
+            'oracle', ${obligationCollateralsV2.oracleAddress},
             'lltv', ${obligationCollateralsV2.lltv}
           )
         ),
         '[]'::jsonb
-      )`.as("collaterals") }).from(obligationCollateralsV2).innerJoin(oracles, sql`${obligationCollateralsV2.oracleChainId} = ${oracles.chainId}
-             AND ${obligationCollateralsV2.oracleAddress} = ${oracles.address}`).where(eq(obligationCollateralsV2.obligationId, offers.obligationId)).as("collaterals_lateral");
+      )`.as("collaterals") }).from(obligationCollateralsV2).where(eq(obligationCollateralsV2.obligationKey, obligationIdKeys.obligationKey)).as("collaterals_lateral");
 			const rows = (await db.select({
 				hash: offers.hash,
+				obligationId: offers.obligationId,
 				maker: offers.groupMaker,
 				assets: offers.assets,
 				obligationUnits: offers.obligationUnits,
@@ -8381,17 +9193,18 @@ function create$9(config) {
 				group: offers.group,
 				session: offers.session,
 				buy: offers.buy,
-				chainId: obligations.chainId,
+				chainId: obligationIdKeys.chainId,
 				loanToken: obligations.loanToken,
 				callbackAddress: offers.callbackAddress,
 				callbackData: offers.callbackData,
 				receiverIfMakerIsSeller: offers.receiverIfMakerIsSeller,
 				collaterals: collateralsLateral.collaterals,
 				blockNumber: offers.blockNumber
-			}).from(offers).innerJoin(obligations, eq(offers.obligationId, obligations.obligationId)).innerJoinLateral(collateralsLateral, sql`true`).where(and(cursor !== null && cursor !== void 0 ? gt(offers.hash, cursor) : void 0, maker !== void 0 ? eq(offers.groupMaker, maker.toLowerCase()) : void 0)).orderBy(asc(offers.hash)).limit(limit)).map((row) => {
+			}).from(offers).innerJoin(obligationIdKeys, eq(offers.obligationId, obligationIdKeys.obligationId)).innerJoin(obligations, eq(obligationIdKeys.obligationKey, obligations.obligationKey)).innerJoinLateral(collateralsLateral, sql`true`).where(and(cursor !== void 0 ? or(gt(offers.hash, cursor.hash), and(eq(offers.hash, cursor.hash), gt(offers.obligationId, cursor.obligationId))) : void 0, maker !== void 0 ? eq(offers.groupMaker, maker.toLowerCase()) : void 0)).orderBy(asc(offers.hash), asc(offers.obligationId)).limit(limit)).map((row) => {
 				const receiverIfMakerIsSeller = (row.receiverIfMakerIsSeller ?? row.maker).toLowerCase();
 				return {
 					hash: row.hash,
+					obligationId: row.obligationId,
 					maker: row.maker,
 					assets: BigInt(row.assets),
 					obligationUnits: BigInt(row.obligationUnits),
@@ -8423,7 +9236,10 @@ function create$9(config) {
 			});
 			return {
 				rows,
-				nextCursor: rows.length === limit ? rows[rows.length - 1].hash : null
+				nextCursor: rows.length === limit ? formatCursor$2({
+					hash: rows[rows.length - 1].hash,
+					obligationId: rows[rows.length - 1].obligationId
+				}) : null
 			};
 		},
 		delete: async (parameters) => {
@@ -8446,7 +9262,7 @@ function create$9(config) {
 			const query = ({ side }) => db.selectDistinctOn([offers.obligationId], {
 				obligationId: offers.obligationId,
 				tick: offers.tick
-			}).from(offers).innerJoin(groups, and(eq(offers.groupChainId, groups.chainId), eq(offers.groupMaker, groups.maker), eq(offers.group, groups.group))).leftJoin(validations, eq(offers.hash, validations.offerHash)).leftJoin(status, eq(validations.statusId, status.id)).where(and(inArray(offers.obligationId, obligationIds), eq(offers.buy, side === "buy"), gte(offers.expiry, now$2), gte(offers.maturity, now$2), lte(offers.start, now$2), sql`(${status.code} IS NULL OR ${status.code} = ${Status.VALID})`)).orderBy(offers.obligationId, side === "buy" ? sql`${offers.tick} ASC` : sql`${offers.tick} DESC`);
+			}).from(offers).innerJoin(groups, and(eq(offers.groupChainId, groups.chainId), eq(offers.groupMaker, groups.maker), eq(offers.group, groups.group))).leftJoin(validations, and(eq(offers.hash, validations.offerHash), eq(offers.obligationId, validations.obligationId))).leftJoin(status, eq(validations.statusId, status.id)).where(and(inArray(offers.obligationId, obligationIds), eq(offers.buy, side === "buy"), gte(offers.expiry, now$2), gte(offers.maturity, now$2), lte(offers.start, now$2), sql`(${status.code} IS NULL OR ${status.code} = ${Status.VALID})`)).orderBy(offers.obligationId, side === "buy" ? sql`${offers.tick} ASC` : sql`${offers.tick} DESC`);
 			const [bestBuys, bestSells] = await Promise.all([query({ side: "buy" }), query({ side: "sell" })]);
 			const quotes = /* @__PURE__ */ new Map();
 			for (const row of bestSells) quotes.set(row.obligationId, {
@@ -8476,6 +9292,18 @@ function create$9(config) {
 		}
 	};
 }
+const HEX_32$2 = /^0x[a-fA-F0-9]{64}$/;
+function parseCursor$2(cursor) {
+	const [hash, obligationId] = cursor.split(":");
+	if (!hash || !obligationId || !HEX_32$2.test(hash) || !HEX_32$2.test(obligationId)) throw new Error("Invalid cursor format");
+	return {
+		hash: hash.toLowerCase(),
+		obligationId: obligationId.toLowerCase()
+	};
+}
+function formatCursor$2(input) {
+	return `${input.hash.toLowerCase()}:${input.obligationId.toLowerCase()}`;
+}
 
 //#endregion
 //#region src/database/domains/Offsets.ts
@@ -8549,14 +9377,15 @@ const create$6 = (db) => {
 		upsert: async (positions$1) => {
 			const positionsMap = /* @__PURE__ */ new Map();
 			for (const p of positions$1) {
-				const key = `${p.chainId}-${p.contract}-${p.user}`.toLowerCase();
-				const zeroKey = `${p.chainId}-${p.contract}-${zeroAddress}`.toLowerCase();
+				const key = `${p.chainId}-${p.contract}-${p.user}-${p.asset}`.toLowerCase();
+				const zeroKey = `${p.chainId}-${p.contract}-${zeroAddress}-${p.asset}`.toLowerCase();
 				if (!positionsMap.has(zeroKey)) positionsMap.set(zeroKey, {
 					chainId: p.chainId,
 					contract: p.contract,
 					user: zeroAddress,
 					balance: 0n,
 					type: p.type,
+					asset: p.asset,
 					blockNumber: p.blockNumber
 				});
 				if (!positionsMap.has(key)) {
@@ -8567,14 +9396,14 @@ const create$6 = (db) => {
 			}
 			if (positionsMap.size === 0) return 0;
 			const rows = Array.from(positionsMap.values()).map((p) => {
-				const positionTypeId = Object.values(Type).indexOf(p.type) + 1;
+				const positionTypeId$1 = positionTypeId(p.type);
 				return {
 					chainId: p.chainId,
 					contract: p.contract.toLowerCase(),
 					user: p.user.toLowerCase(),
-					positionTypeId,
+					positionTypeId: positionTypeId$1,
 					...p.balance !== void 0 ? { balance: p.balance.toString() } : {},
-					...p.asset !== void 0 ? { asset: p.asset.toLowerCase() } : {},
+					asset: p.asset.toLowerCase(),
 					blockNumber: p.blockNumber
 				};
 			});
@@ -8584,11 +9413,12 @@ const create$6 = (db) => {
 					target: [
 						positions.chainId,
 						positions.contract,
-						positions.user
+						positions.user,
+						positions.positionTypeId,
+						positions.asset
 					],
 					set: {
 						balance: sql`EXCLUDED.balance`,
-						asset: sql`COALESCE(EXCLUDED.asset, ${positions.asset})`,
 						blockNumber: sql`EXCLUDED.block_number`,
 						updatedAt: sql`NOW()`
 					},
@@ -8607,20 +9437,23 @@ const create$6 = (db) => {
 				cursor = {
 					chainId: parsed.chainId,
 					contract: parsed.contract,
-					user: parsed.user
+					user: parsed.user,
+					positionTypeId: parsed.positionTypeId ?? 0,
+					asset: parsed.asset ?? ""
 				};
 			}
-			const positions$2 = await db.select().from(positions).where(and(ne(positions.user, zeroAddress), filled === void 0 ? sql`true` : sql`${positions.balance} IS ${filled === true ? sql`NOT` : sql``} NULL`, type !== void 0 ? eq(positions.positionTypeId, Object.values(Type).indexOf(type) + 1) : sql`true`, chainId !== void 0 ? eq(positions.chainId, chainId) : sql`true`, (() => {
+			const positions$2 = await db.select().from(positions).where(and(ne(positions.user, zeroAddress), filled === void 0 ? sql`true` : sql`${positions.balance} IS ${filled === true ? sql`NOT` : sql``} NULL`, type !== void 0 ? eq(positions.positionTypeId, positionTypeId(type)) : sql`true`, chainId !== void 0 ? eq(positions.chainId, chainId) : sql`true`, (() => {
 				if (cursor === null || cursor === void 0) return sql`true`;
 				return sql`
-                (${chainId === void 0 ? sql`"chain_id", ` : sql``}"contract", "user") > (${chainId === void 0 ? sql`${cursor.chainId}, ` : sql``}${cursor.contract}, ${cursor.user})
+                (${chainId === void 0 ? sql`"chain_id", ` : sql``}"contract", "user", "position_type_id", "asset") > (${chainId === void 0 ? sql`${cursor.chainId}, ` : sql``}${cursor.contract}, ${cursor.user}, ${cursor.positionTypeId}, ${cursor.asset})
                 `;
-			})())).orderBy(asc(positions.chainId), asc(positions.contract), asc(positions.user), asc(positions.blockNumber)).limit(limit);
+			})())).orderBy(asc(positions.chainId), asc(positions.contract), asc(positions.user), asc(positions.positionTypeId), asc(positions.asset)).limit(limit);
 			const nextCursor = positions$2.length === limit ? Buffer.from(JSON.stringify({
 				chainId: positions$2[positions$2.length - 1].chainId.toString(),
 				contract: positions$2[positions$2.length - 1].contract,
 				user: positions$2[positions$2.length - 1].user,
-				blockNumber: positions$2[positions$2.length - 1].blockNumber.toString()
+				positionTypeId: positions$2[positions$2.length - 1].positionTypeId,
+				asset: positions$2[positions$2.length - 1].asset
 			})).toString("base64url") : null;
 			return {
 				positions: positions$2.map((p) => ({
@@ -8629,14 +9462,14 @@ const create$6 = (db) => {
 					user: p.user,
 					type: Object.values(Type)[p.positionTypeId - 1],
 					balance: p.balance !== null ? BigInt(p.balance) : void 0,
-					...p.asset !== null ? { asset: p.asset } : {},
+					asset: p.asset,
 					blockNumber: p.blockNumber
 				})),
 				nextCursor
 			};
 		},
 		getByUser: async (parameters) => {
-			const { user, limit = DEFAULT_LIMIT$2, cursor: encodedCursor } = parameters;
+			const { user, type, limit = DEFAULT_LIMIT$2, cursor: encodedCursor } = parameters;
 			let cursor = null;
 			if (encodedCursor !== null && encodedCursor !== void 0) {
 				const parsed = JSON.parse(Buffer.from(encodedCursor, "base64url").toString("utf8"));
@@ -8644,6 +9477,8 @@ const create$6 = (db) => {
 				cursor = {
 					chainId: parsed.chainId,
 					contract: parsed.contract,
+					positionTypeId: parsed.positionTypeId ?? 0,
+					asset: parsed.asset ?? "",
 					obligationId: parsed.obligationId ?? null
 				};
 			}
@@ -8731,6 +9566,8 @@ const create$6 = (db) => {
           p.contract,
           p."user",
           p.block_number,
+          p.position_type_id,
+          p.asset,
           po.obligation_id,
           COALESCE(po.reserved_balance, '0') AS reserved_balance
         FROM ${positions} p
@@ -8740,14 +9577,18 @@ const create$6 = (db) => {
           AND LOWER(po."user") = LOWER(p."user")
         WHERE LOWER(p."user") = LOWER(${user})
           AND p."user" != ${zeroAddress}
-          ${cursor !== null ? sql`AND (p.chain_id, p.contract, COALESCE(po.obligation_id, '')) > (${cursor.chainId}, ${cursor.contract}, ${cursor.obligationId ?? ""})` : sql``}
-        ORDER BY p.chain_id ASC, p.contract ASC, po.obligation_id ASC NULLS FIRST
+          ${type !== void 0 ? sql`AND p.position_type_id = ${positionTypeId(type)}` : sql``}
+          ${cursor !== null ? sql`AND (p.chain_id, p.contract, p.position_type_id, p.asset, COALESCE(po.obligation_id, '')) > (${cursor.chainId}, ${cursor.contract}, ${cursor.positionTypeId}, ${cursor.asset}, ${cursor.obligationId ?? ""})` : sql``}
+        ORDER BY p.chain_id ASC, p.contract ASC, p.position_type_id ASC, p.asset ASC, po.obligation_id ASC NULLS FIRST
         LIMIT ${limit}
       `);
-			const nextCursor = raw.rows.length === limit ? Buffer.from(JSON.stringify({
-				chainId: raw.rows[raw.rows.length - 1].chain_id.toString(),
-				contract: raw.rows[raw.rows.length - 1].contract,
-				obligationId: raw.rows[raw.rows.length - 1].obligation_id
+			const lastRow = raw.rows[raw.rows.length - 1];
+			const nextCursor = raw.rows.length === limit && lastRow !== void 0 ? Buffer.from(JSON.stringify({
+				chainId: lastRow.chain_id.toString(),
+				contract: lastRow.contract,
+				positionTypeId: lastRow.position_type_id,
+				asset: lastRow.asset,
+				obligationId: lastRow.obligation_id
 			})).toString("base64url") : null;
 			return {
 				positions: raw.rows.map((row) => ({
@@ -8762,21 +9603,23 @@ const create$6 = (db) => {
 			};
 		},
 		setEmptyAfter: async (parameters) => {
-			const { chainId, blockNumber } = parameters;
+			const { chainId, blockNumber, type } = parameters;
+			const typeId = positionTypeId(type);
 			return await db.transaction(async (tx) => {
 				const updatedPositions = await tx.update(positions).set({
 					balance: null,
 					blockNumber,
 					updatedAt: sql`NOW()`
-				}).where(and(eq(positions.chainId, chainId), sql`${positions.blockNumber} >= ${blockNumber}`)).returning();
+				}).where(and(eq(positions.chainId, chainId), sql`${positions.blockNumber} >= ${blockNumber}`, eq(positions.positionTypeId, typeId))).returning();
 				if (updatedPositions.length === 0) return 0;
 				await tx.execute(sql`
           DELETE FROM ${transfers} t
-          USING (VALUES ${sql.join(updatedPositions.map((u) => sql`(${u.chainId}::bigint, ${u.contract}::varchar(42), ${u.user}::varchar(42))`), sql`,`)}) AS s(chain_id, "contract", "user")
+          USING (VALUES ${sql.join(updatedPositions.map((u) => sql`(${u.chainId}::bigint, ${u.contract}::varchar(66), ${u.user}::varchar(42))`), sql`,`)}) AS s(chain_id, "contract", "user")
           WHERE
             t.chain_id = s.chain_id
             AND t."contract" = s."contract"
             AND (t."from" = s."user" OR t."to" = s."user")
+            AND t.position_type_id = ${typeId}
         `);
 				return updatedPositions.length;
 			});
@@ -8786,33 +9629,35 @@ const create$6 = (db) => {
 
 //#endregion
 //#region src/database/domains/Transfers.ts
-const create$5 = (db) => ({ create: async (transfers$1) => {
-	if (transfers$1.length === 0) return 0;
-	return await db.transaction(async (dbTx) => {
-		let totalInserted = 0;
-		for (const transfersBatch of batch$1(transfers$1, DEFAULT_BATCH_SIZE)) {
-			const { rows: inserted } = await dbTx.execute(sql`
-          INSERT INTO ${transfers} (event_id, chain_id, "contract", "from", "to", "value", block_number)
-          SELECT * FROM (VALUES ${sql.join(transfersBatch.map((transfer) => sql`(${transfer.id}::varchar(128), ${transfer.chainId}::bigint, ${transfer.contract.toLowerCase()}::varchar(42), ${transfer.from.toLowerCase()}::varchar(42), ${transfer.to.toLowerCase()}::varchar(42), ${transfer.value.toString()}::numeric(78, 0), ${transfer.blockNumber}::bigint)`), sql`,`)}) AS v(event_id, chain_id, "contract", "from", "to", "value", block_number)
+const create$5 = (db) => ({
+	create: async (transfers$1) => {
+		if (transfers$1.length === 0) return 0;
+		const typeId = positionTypeId(transfers$1[0].type);
+		return await db.transaction(async (dbTx) => {
+			let totalInserted = 0;
+			for (const transfersBatch of batch$1(transfers$1, DEFAULT_BATCH_SIZE)) {
+				const { rows: inserted } = await dbTx.execute(sql`
+          INSERT INTO ${transfers} (event_id, chain_id, "contract", "from", "to", "value", position_type_id, asset, block_number)
+          SELECT * FROM (VALUES ${sql.join(transfersBatch.map((transfer) => sql`(${transfer.id}::varchar(128), ${transfer.chainId}::bigint, ${transfer.contract.toLowerCase()}::varchar(66), ${transfer.from.toLowerCase()}::varchar(42), ${transfer.to.toLowerCase()}::varchar(42), ${transfer.value.toString()}::numeric(78, 0), ${typeId}::integer, ${transfer.asset.toLowerCase()}::varchar(42), ${transfer.blockNumber}::bigint)`), sql`,`)}) AS v(event_id, chain_id, "contract", "from", "to", "value", position_type_id, asset, block_number)
           WHERE
             EXISTS (
               SELECT 1 FROM ${positions} p
-              WHERE p.chain_id = v.chain_id AND p."contract" = v."contract" AND p."user" = v."from" AND p.balance IS NOT NULL
+              WHERE p.chain_id = v.chain_id AND p."contract" = v."contract" AND p."user" = v."from" AND p.position_type_id = v.position_type_id AND p.asset = v.asset AND p.balance IS NOT NULL
             )
           AND
             EXISTS (
               SELECT 1 FROM ${positions} p
-              WHERE p.chain_id = v.chain_id AND p."contract" = v."contract" AND p."user" = v."to" AND p.balance IS NOT NULL
+              WHERE p.chain_id = v.chain_id AND p."contract" = v."contract" AND p."user" = v."to" AND p.position_type_id = v.position_type_id AND p.asset = v.asset AND p.balance IS NOT NULL
             )
           ON CONFLICT DO NOTHING
           RETURNING *;
           `);
-			if (inserted.length === 0) continue;
-			await dbTx.execute(sql`
+				if (inserted.length === 0) continue;
+				await dbTx.execute(sql`
           WITH inserted AS (
             VALUES ${sql.join(inserted.map((t) => {
-				return sql`(${t.chain_id}::bigint, ${t.contract}::varchar(42), ${t.from}::varchar(42), ${t.to}::varchar(42), ${t.value}::numeric(78, 0), ${t.block_number}::bigint)`;
-			}), sql`,`)}
+					return sql`(${t.chain_id}::bigint, ${t.contract}::varchar(66), ${t.from}::varchar(42), ${t.to}::varchar(42), ${t.value}::numeric(78, 0), ${t.asset}::varchar(42), ${t.block_number}::bigint)`;
+				}), sql`,`)}
           ),
           new_transfers AS (
             SELECT
@@ -8821,7 +9666,8 @@ const create$5 = (db) => ({ create: async (transfers$1) => {
               column3        AS "from",
               column4        AS "to",
               column5        AS "value",
-              column6        AS block_number
+              column6        AS asset,
+              column7        AS block_number
             FROM inserted
           ),
           diffs AS (
@@ -8830,6 +9676,7 @@ const create$5 = (db) => ({ create: async (transfers$1) => {
               nt."contract",
               nt."from" AS "user",
               -nt."value" AS delta,
+              nt.asset,
               nt.block_number
             FROM new_transfers nt
             UNION ALL
@@ -8838,6 +9685,7 @@ const create$5 = (db) => ({ create: async (transfers$1) => {
               nt."contract",
               nt."to" AS "user",
               nt."value" AS delta,
+              nt.asset,
               nt.block_number
             FROM new_transfers nt
           ),
@@ -8847,12 +9695,15 @@ const create$5 = (db) => ({ create: async (transfers$1) => {
               d."contract",
               d."user",
               d.delta,
+              d.asset,
               d.block_number
             FROM diffs d
             JOIN ${positions} p
               ON p.chain_id = d.chain_id
              AND p."contract" = d."contract"
              AND p."user"   = d."user"
+             AND p.position_type_id = ${typeId}
+             AND p.asset = d.asset
             -- Only keep per-event diffs that are at or after the current position block
             WHERE d.block_number >= p.block_number
           ),
@@ -8861,10 +9712,11 @@ const create$5 = (db) => ({ create: async (transfers$1) => {
               chain_id,
               "contract",
               "user",
+              asset,
               SUM(delta)        AS sum_delta,
               MAX(block_number) AS max_block
             FROM valid_diffs
-            GROUP BY 1,2,3
+            GROUP BY 1,2,3,4
           )
           UPDATE ${positions} AS p
           SET
@@ -8876,12 +9728,109 @@ const create$5 = (db) => ({ create: async (transfers$1) => {
             p.chain_id = a.chain_id
             AND p."contract" = a."contract"
             AND p."user" = a."user"
+            AND p.asset = a.asset
+            AND p.position_type_id = ${typeId}
         `);
-			totalInserted += inserted.length;
-		}
-		return totalInserted;
-	});
-} });
+				totalInserted += inserted.length;
+			}
+			return totalInserted;
+		});
+	},
+	delete: async (parameters) => {
+		const { chainId, blockNumberGte, positionTypeId } = parameters;
+		return await db.transaction(async (dbTx) => {
+			const { rows: toDelete } = await dbTx.execute(sql`
+        SELECT event_id, chain_id, "contract", "from", "to", "value"::text, asset, block_number
+        FROM ${transfers}
+        WHERE chain_id = ${chainId}
+          AND position_type_id = ${positionTypeId}
+          AND block_number >= ${blockNumberGte}
+      `);
+			if (toDelete.length === 0) return 0;
+			await dbTx.execute(sql`
+        WITH to_delete AS (
+          VALUES ${sql.join(toDelete.map((t) => sql`(${t.chain_id}::bigint, ${t.contract}::varchar(66), ${t.from}::varchar(42), ${t.to}::varchar(42), ${t.value}::numeric(78, 0), ${t.asset}::varchar(42))`), sql`,`)}
+        ),
+        reverse_diffs AS (
+          SELECT column1 AS chain_id, column2 AS "contract", column3 AS "user", column5 AS delta, column6 AS asset
+          FROM to_delete
+          UNION ALL
+          SELECT column1 AS chain_id, column2 AS "contract", column4 AS "user", -column5 AS delta, column6 AS asset
+          FROM to_delete
+        ),
+        aggregated AS (
+          SELECT chain_id, "contract", "user", asset, SUM(delta) AS sum_delta
+          FROM reverse_diffs
+          GROUP BY 1,2,3,4
+        ),
+        remaining_max AS (
+          SELECT t.chain_id, t."contract",
+            CASE WHEN t."from" = a."user" THEN t."from" ELSE t."to" END AS "user",
+            t.asset,
+            MAX(t.block_number) AS max_block
+          FROM ${transfers} t
+          JOIN aggregated a
+            ON t.chain_id = a.chain_id AND t."contract" = a."contract"
+            AND t.asset = a.asset
+            AND (t."from" = a."user" OR t."to" = a."user")
+          WHERE t.position_type_id = ${positionTypeId}
+            AND t.block_number < ${blockNumberGte}
+          GROUP BY t.chain_id, t."contract",
+            CASE WHEN t."from" = a."user" THEN t."from" ELSE t."to" END,
+            t.asset
+        )
+        UPDATE ${positions} AS p
+        SET
+          balance = COALESCE(p.balance, 0) + a.sum_delta,
+          block_number = COALESCE(rm.max_block, p.block_number),
+          updated_at = NOW()
+        FROM aggregated a
+        LEFT JOIN remaining_max rm
+          ON rm.chain_id = a.chain_id AND rm."contract" = a."contract" AND rm."user" = a."user" AND rm.asset = a.asset
+        WHERE p.chain_id = a.chain_id
+          AND p."contract" = a."contract"
+          AND p."user" = a."user"
+          AND p.asset = a.asset
+          AND p.position_type_id = ${positionTypeId}
+      `);
+			await dbTx.execute(sql`
+        DELETE FROM ${transfers}
+        WHERE chain_id = ${chainId}
+          AND position_type_id = ${positionTypeId}
+          AND block_number >= ${blockNumberGte}
+      `);
+			await dbTx.execute(sql`
+        DELETE FROM ${positions} p
+        USING (
+          SELECT DISTINCT chain_id, "contract", "user", asset
+          FROM (
+            SELECT chain_id, "contract", "from" AS "user", asset FROM (
+              VALUES ${sql.join(toDelete.map((t) => sql`(${t.chain_id}::bigint, ${t.contract}::varchar(66), ${t.from}::varchar(42), ${t.asset}::varchar(42))`), sql`,`)}
+            ) AS d(chain_id, "contract", "from", asset)
+            UNION
+            SELECT chain_id, "contract", "to" AS "user", asset FROM (
+              VALUES ${sql.join(toDelete.map((t) => sql`(${t.chain_id}::bigint, ${t.contract}::varchar(66), ${t.to}::varchar(42), ${t.asset}::varchar(42))`), sql`,`)}
+            ) AS d(chain_id, "contract", "to", asset)
+          ) AS combined
+        ) AS affected
+        WHERE p.chain_id = affected.chain_id
+          AND p."contract" = affected."contract"
+          AND p."user" = affected."user"
+          AND p.asset = affected.asset
+          AND p.position_type_id = ${positionTypeId}
+          AND NOT EXISTS (
+            SELECT 1 FROM ${transfers} t
+            WHERE t.chain_id = p.chain_id
+              AND t."contract" = p."contract"
+              AND t.asset = p.asset
+              AND t.position_type_id = ${positionTypeId}
+              AND (t."from" = p."user" OR t."to" = p."user")
+          )
+      `);
+			return toDelete.length;
+		});
+	}
+});
 
 //#endregion
 //#region src/database/domains/Trees.ts
@@ -8894,34 +9843,22 @@ const create$5 = (db) => ({ create: async (transfers$1) => {
 function create$4(config) {
 	const db = config.db;
 	return {
-		create: async (trees$1) => {
+		upsert: async (trees$1) => {
 			if (trees$1.length === 0) return [];
 			try {
 				return await db.transaction(async (dbTx) => {
 					const roots = [];
-					for (const { tree, signature } of trees$1) {
-						const root = tree.root.toLowerCase();
-						roots.push(root);
+					for (const { root, signature } of trees$1) {
+						const normalizedRoot = root.toLowerCase();
+						const normalizedSignature = signature.toLowerCase();
+						roots.push(normalizedRoot);
 						await dbTx.insert(trees).values({
-							root,
-							rootSignature: signature.toLowerCase()
+							root: normalizedRoot,
+							rootSignature: normalizedSignature
 						}).onConflictDoUpdate({
 							target: [trees.root],
 							set: {
-								rootSignature: signature.toLowerCase(),
-								createdAt: sql`NOW()`
-							}
-						});
-						const pathRows = proofs(tree).map((proof) => ({
-							offerHash: hash(proof.offer).toLowerCase(),
-							treeRoot: root,
-							proofNodes: concatenateProofs(proof.path)
-						}));
-						for (const batch of batch$1(pathRows, DEFAULT_BATCH_SIZE)) await dbTx.insert(merklePaths).values(batch).onConflictDoUpdate({
-							target: [merklePaths.offerHash],
-							set: {
-								treeRoot: sql`excluded.tree_root`,
-								proofNodes: sql`excluded.proof_nodes`,
+								rootSignature: normalizedSignature,
 								createdAt: sql`NOW()`
 							}
 						});
@@ -8930,24 +9867,60 @@ function create$4(config) {
 				});
 			} catch (err) {
 				const error = err instanceof Error ? err : new Error(String(err));
-				throw new Error("Trees.create failed. Ensure offers exist before inserting merkle paths.", { cause: error });
+				throw new Error("Trees.upsert failed. Ensure obligations and offers exist before upserting roots.", { cause: error });
+			}
+		},
+		upsertPaths: async (paths) => {
+			if (paths.length === 0) return;
+			const rows = paths.map((path) => ({
+				offerHash: path.offerHash.toLowerCase(),
+				obligationId: path.obligationId.toLowerCase(),
+				treeRoot: path.treeRoot.toLowerCase(),
+				proofNodes: concatenateProofs(path.proof)
+			}));
+			try {
+				for (const batch of batch$1(rows, DEFAULT_BATCH_SIZE)) await db.insert(merklePaths).values(batch).onConflictDoUpdate({
+					target: [merklePaths.offerHash, merklePaths.obligationId],
+					set: {
+						treeRoot: sql`excluded.tree_root`,
+						proofNodes: sql`excluded.proof_nodes`,
+						createdAt: sql`NOW()`
+					}
+				});
+			} catch (err) {
+				const error = err instanceof Error ? err : new Error(String(err));
+				throw new Error("Trees.upsertPaths failed. Ensure offers and roots exist before inserting merkle paths.", { cause: error });
 			}
 		},
-		getAttestations: async (hashes) => {
-			if (hashes.length === 0) return /* @__PURE__ */ new Map();
-			const normalizedHashes = hashes.map((h) => h.toLowerCase());
+		getAttestations: async (references) => {
+			if (references.length === 0) return /* @__PURE__ */ new Map();
+			const normalizedReferences = references.map((reference) => ({
+				offerHash: reference.offerHash.toLowerCase(),
+				obligationId: reference.obligationId.toLowerCase()
+			}));
+			const hashes = [...new Set(normalizedReferences.map((reference) => reference.offerHash))];
+			const obligationIds = [...new Set(normalizedReferences.map((reference) => reference.obligationId))];
 			const results = await db.select({
 				offerHash: merklePaths.offerHash,
+				obligationId: merklePaths.obligationId,
 				treeRoot: merklePaths.treeRoot,
 				proofNodes: merklePaths.proofNodes,
 				rootSignature: trees.rootSignature
-			}).from(merklePaths).innerJoin(trees, eq(merklePaths.treeRoot, trees.root)).where(inArray(merklePaths.offerHash, normalizedHashes));
+			}).from(merklePaths).innerJoin(trees, eq(merklePaths.treeRoot, trees.root)).where(sql`${inArray(merklePaths.offerHash, hashes)} AND ${inArray(merklePaths.obligationId, obligationIds)}`);
+			const expectedKeys = new Set(normalizedReferences.map(toAttestationKey));
 			const attestationMap = /* @__PURE__ */ new Map();
-			for (const row of results) attestationMap.set(row.offerHash, {
-				root: row.treeRoot,
-				signature: row.rootSignature,
-				proof: splitProofs(row.proofNodes)
-			});
+			for (const row of results) {
+				const key = toAttestationKey({
+					offerHash: row.offerHash,
+					obligationId: row.obligationId
+				});
+				if (!expectedKeys.has(key)) continue;
+				attestationMap.set(key, {
+					root: row.treeRoot.toLowerCase(),
+					signature: row.rootSignature.toLowerCase(),
+					proof: splitProofs(row.proofNodes)
+				});
+			}
 			return attestationMap;
 		}
 	};
@@ -8958,7 +9931,7 @@ function create$4(config) {
 */
 function concatenateProofs(proofs) {
 	if (proofs.length === 0) return "0x";
-	return `0x${proofs.map((p) => p.slice(2)).join("")}`;
+	return `0x${proofs.map((proof) => proof.toLowerCase().slice(2)).join("")}`;
 }
 /**
 * Splits a concatenated hex string back into an array of 32-byte hex hashes.
@@ -8968,9 +9941,12 @@ function splitProofs(concatenated) {
 	if (!concatenated || concatenated === "0x" || concatenated.length <= 2) return [];
 	const hex = concatenated.slice(2);
 	const proofs = [];
-	for (let i = 0; i < hex.length; i += 64) proofs.push(`0x${hex.slice(i, i + 64)}`);
+	for (let i = 0; i < hex.length; i += 64) proofs.push(`0x${hex.slice(i, i + 64).toLowerCase()}`);
 	return proofs;
 }
+function toAttestationKey(offer) {
+	return `${offer.offerHash.toLowerCase()}:${offer.obligationId.toLowerCase()}`;
+}
 
 //#endregion
 //#region src/database/domains/Validations.ts
@@ -8979,26 +9955,26 @@ function create$3(db) {
 	return {
 		get: async (params) => {
 			const { status: status$2, cursor, limit = DEFAULT_LIMIT$1 } = params ?? {};
-			if (cursor !== null && cursor !== void 0) {
-				if (!cursor.startsWith("0x") || cursor.length !== 66) throw new Error("Invalid cursor format");
-			}
+			const parsedCursor = cursor !== null && cursor !== void 0 ? parseCursor$1(cursor) : void 0;
 			let query = db.select({
 				offerHash: validations.offerHash,
+				obligationId: validations.obligationId,
 				code: status.code
 			}).from(validations).innerJoin(status, eq(validations.statusId, status.id));
 			if (status$2 !== void 0) query = query.where(eq(status.code, status$2));
-			if (cursor !== null && cursor !== void 0) {
-				const cursorCondition = gt(validations.offerHash, cursor.toLowerCase());
+			if (parsedCursor !== void 0) {
+				const cursorCondition = or(gt(validations.offerHash, parsedCursor.offerHash), and(eq(validations.offerHash, parsedCursor.offerHash), gt(validations.obligationId, parsedCursor.obligationId)));
 				if (status$2 !== void 0) query = query.where(and(eq(status.code, status$2), cursorCondition));
 				else query = query.where(cursorCondition);
 			}
-			const mapped = (await query.orderBy(asc(validations.offerHash)).limit(limit)).map((row) => ({
+			const mapped = (await query.orderBy(asc(validations.offerHash), asc(validations.obligationId)).limit(limit)).map((row) => ({
 				offerHash: row.offerHash,
+				obligationId: row.obligationId,
 				status: row.code
 			}));
 			return {
 				validations: mapped,
-				nextCursor: mapped.length === limit ? mapped[mapped.length - 1].offerHash : null
+				nextCursor: mapped.length === limit ? formatCursor$1(mapped[mapped.length - 1]) : null
 			};
 		},
 		upsert: async (results) => {
@@ -9008,6 +9984,7 @@ function create$3(db) {
 			if (invalidStatuses.length > 0) throw new Error(`Unknown validation status: ${invalidStatuses.join(", ")}`);
 			const normalized = results.map((r) => ({
 				offerHash: r.offerHash.toLowerCase(),
+				obligationId: r.obligationId.toLowerCase(),
 				status: r.status
 			}));
 			const uniqueStatuses = Array.from(new Set(normalized.map((r) => r.status)));
@@ -9019,10 +9996,11 @@ function create$3(db) {
 			for (const status of uniqueStatuses) if (!statusMap.has(status)) throw new Error(`Unknown validation status: ${status}`);
 			const values = normalized.map((row) => ({
 				offerHash: row.offerHash,
+				obligationId: row.obligationId,
 				statusId: statusMap.get(row.status)
 			}));
 			for (const batch of batch$1(values, DEFAULT_BATCH_SIZE)) await db.insert(validations).values(batch).onConflictDoUpdate({
-				target: [validations.offerHash],
+				target: [validations.offerHash, validations.obligationId],
 				set: {
 					statusId: sql`excluded.status_id`,
 					updatedAt: sql`NOW()`
@@ -9031,6 +10009,18 @@ function create$3(db) {
 		}
 	};
 }
+const HEX_32$1 = /^0x[a-fA-F0-9]{64}$/;
+function parseCursor$1(cursor) {
+	const [offerHash, obligationId] = cursor.split(":");
+	if (!offerHash || !obligationId || !HEX_32$1.test(offerHash) || !HEX_32$1.test(obligationId)) throw new Error("Invalid cursor format");
+	return {
+		offerHash: offerHash.toLowerCase(),
+		obligationId: obligationId.toLowerCase()
+	};
+}
+function formatCursor$1(input) {
+	return `${input.offerHash.toLowerCase()}:${input.obligationId.toLowerCase()}`;
+}
 
 //#endregion
 //#region src/database/readers/ObligationsListing.ts
@@ -9073,23 +10063,22 @@ function create$2(parameters) {
 		const loanTokenFilter = loanTokens !== void 0 && loanTokens.length > 0 ? sql`(${sql.join(loanTokens.map((token) => sql`LOWER(${obligations.loanToken}) = ${token.toLowerCase()}`), sql` OR `)})` : void 0;
 		const collateralFilter = collateralTokens !== void 0 && collateralTokens.length > 0 ? sql`EXISTS (
           SELECT 1 FROM ${obligationCollateralsV2} oc
-          WHERE oc.obligation_id = ${obligations.obligationId}
+          WHERE oc.obligation_key = ${obligations.obligationKey}
           AND (${sql.join(collateralTokens.map((token) => sql`LOWER(oc.asset) = ${token.toLowerCase()}`), sql` OR `)})
         )` : void 0;
-		const bestAskTick = db.select({ askTick: offers.tick }).from(offers).innerJoin(groups, and(eq(offers.groupChainId, groups.chainId), eq(offers.groupMaker, groups.maker), eq(offers.group, groups.group))).leftJoin(validations, eq(offers.hash, validations.offerHash)).leftJoin(status, eq(validations.statusId, status.id)).where(and(eq(offers.obligationId, obligations.obligationId), eq(offers.buy, false), gte(offers.expiry, now$1), gte(offers.maturity, now$1), lte(offers.start, now$1), sql`(${status.code} IS NULL OR ${status.code} = ${Status.VALID})`)).orderBy(desc(offers.tick)).limit(1).as("best_ask_tick");
-		const bestBidTick = db.select({ bidTick: offers.tick }).from(offers).innerJoin(groups, and(eq(offers.groupChainId, groups.chainId), eq(offers.groupMaker, groups.maker), eq(offers.group, groups.group))).leftJoin(validations, eq(offers.hash, validations.offerHash)).leftJoin(status, eq(validations.statusId, status.id)).where(and(eq(offers.obligationId, obligations.obligationId), eq(offers.buy, true), gte(offers.expiry, now$1), gte(offers.maturity, now$1), lte(offers.start, now$1), sql`(${status.code} IS NULL OR ${status.code} = ${Status.VALID})`)).orderBy(asc(offers.tick)).limit(1).as("best_bid_tick");
+		const bestAskTick = db.select({ askTick: offers.tick }).from(offers).innerJoin(groups, and(eq(offers.groupChainId, groups.chainId), eq(offers.groupMaker, groups.maker), eq(offers.group, groups.group))).leftJoin(validations, and(eq(offers.hash, validations.offerHash), eq(offers.obligationId, validations.obligationId))).leftJoin(status, eq(validations.statusId, status.id)).where(and(eq(offers.obligationId, obligationIdKeys.obligationId), eq(offers.buy, false), gte(offers.expiry, now$1), gte(offers.maturity, now$1), lte(offers.start, now$1), sql`(${status.code} IS NULL OR ${status.code} = ${Status.VALID})`)).orderBy(desc(offers.tick)).limit(1).as("best_ask_tick");
+		const bestBidTick = db.select({ bidTick: offers.tick }).from(offers).innerJoin(groups, and(eq(offers.groupChainId, groups.chainId), eq(offers.groupMaker, groups.maker), eq(offers.group, groups.group))).leftJoin(validations, and(eq(offers.hash, validations.offerHash), eq(offers.obligationId, validations.obligationId))).leftJoin(status, eq(validations.statusId, status.id)).where(and(eq(offers.obligationId, obligationIdKeys.obligationId), eq(offers.buy, true), gte(offers.expiry, now$1), gte(offers.maturity, now$1), lte(offers.start, now$1), sql`(${status.code} IS NULL OR ${status.code} = ${Status.VALID})`)).orderBy(asc(offers.tick)).limit(1).as("best_bid_tick");
 		const obligationsWithQuotes = db.select({
-			obligationId: obligations.obligationId,
-			chainId: obligations.chainId,
+			obligationId: obligationIdKeys.obligationId,
+			chainId: obligationIdKeys.chainId,
 			loanToken: obligations.loanToken,
-			collaterals: sql`ARRAY_AGG(jsonb_build_object('asset', ${obligationCollateralsV2.asset}, 'oracle', ${oracles.address}, 'lltv', ${obligationCollateralsV2.lltv}))`.as("collaterals"),
+			collaterals: sql`ARRAY_AGG(jsonb_build_object('asset', ${obligationCollateralsV2.asset}, 'oracle', ${obligationCollateralsV2.oracleAddress}, 'lltv', ${obligationCollateralsV2.lltv}))`.as("collaterals"),
 			maturity: obligations.maturity,
 			askTick: sql`MAX(${bestAskTick.askTick})`.as("ask_tick"),
 			bidTick: sql`MAX(${bestBidTick.bidTick})`.as("bid_tick"),
 			ask: sql`COALESCE(MAX(${bestAskTick.askTick}) + 1, 0)`.as("ask"),
 			bid: sql`COALESCE(MAX(${bestBidTick.bidTick}) + 1, 0)`.as("bid")
-		}).from(obligations).innerJoin(obligationCollateralsV2, eq(obligations.obligationId, obligationCollateralsV2.obligationId)).innerJoin(oracles, sql`${obligationCollateralsV2.oracleChainId} = ${oracles.chainId}
-         AND ${obligationCollateralsV2.oracleAddress} = ${oracles.address}`).leftJoinLateral(bestAskTick, sql`true`).leftJoinLateral(bestBidTick, sql`true`).groupBy(obligations.obligationId).where(and(ids !== void 0 && ids.length > 0 ? inArray(obligations.obligationId, ids) : void 0, chainIds !== void 0 && chainIds.length > 0 ? inArray(obligations.chainId, chainIds) : void 0, loanTokenFilter, maturities !== void 0 && maturities.length > 0 ? inArray(obligations.maturity, maturities) : gte(obligations.maturity, now$1), collateralFilter)).as("obligations_with_quotes");
+		}).from(obligationIdKeys).innerJoin(obligations, eq(obligationIdKeys.obligationKey, obligations.obligationKey)).innerJoin(obligationCollateralsV2, eq(obligations.obligationKey, obligationCollateralsV2.obligationKey)).leftJoinLateral(bestAskTick, sql`true`).leftJoinLateral(bestBidTick, sql`true`).groupBy(obligationIdKeys.obligationId, obligationIdKeys.chainId, obligations.loanToken, obligations.maturity).where(and(ids !== void 0 && ids.length > 0 ? inArray(obligationIdKeys.obligationId, ids) : void 0, chainIds !== void 0 && chainIds.length > 0 ? inArray(obligationIdKeys.chainId, chainIds) : void 0, loanTokenFilter, maturities !== void 0 && maturities.length > 0 ? inArray(obligations.maturity, maturities) : gte(obligations.maturity, now$1), collateralFilter)).as("obligations_with_quotes");
 		const sortColumns = {
 			id: obligationsWithQuotes.obligationId,
 			ask: obligationsWithQuotes.ask,
@@ -9109,22 +10098,25 @@ function create$2(parameters) {
 		}).from(obligationsWithQuotes).where(buildCursorFilter(sortColumns, sort, cursorValues)).orderBy(...buildOrderBy(sortColumns, sort)).limit(limit + 1);
 		const hasMore = rows.length > limit;
 		const listedRows = (hasMore ? rows.slice(0, limit) : rows).map((row) => {
+			const obligation = from$13({
+				loanToken: row.loanToken,
+				collaterals: row.collaterals.sort((left, right) => left.asset.localeCompare(right.asset)).map((collateral) => from$14({
+					asset: collateral.asset,
+					oracle: collateral.oracle,
+					lltv: from$15(BigInt(collateral.lltv))
+				})),
+				maturity: row.maturity
+			});
+			const quote = from$9({
+				obligationId: row.obligationId,
+				ask: { tick: row.askTick },
+				bid: { tick: row.bidTick }
+			});
 			return {
-				obligation: from$13({
-					chainId: row.chainId,
-					loanToken: row.loanToken,
-					collaterals: row.collaterals.sort((left, right) => left.asset.localeCompare(right.asset)).map((collateral) => from$14({
-						asset: collateral.asset,
-						oracle: collateral.oracle,
-						lltv: from$15(BigInt(collateral.lltv))
-					})),
-					maturity: row.maturity
-				}),
-				quote: from$9({
-					obligationId: row.obligationId,
-					ask: { tick: row.askTick },
-					bid: { tick: row.bidTick }
-				}),
+				obligationId: row.obligationId,
+				chainId: row.chainId,
+				obligation,
+				quote,
 				cursorValues: {
 					id: row.obligationId,
 					ask: toBigInt(row.ask),
@@ -9142,6 +10134,8 @@ function create$2(parameters) {
 		}) : null;
 		return {
 			obligations: listedRows.map((row) => ({
+				obligationId: row.obligationId,
+				chainId: row.chainId,
 				obligation: row.obligation,
 				quote: row.quote
 			})),
@@ -9445,7 +10439,7 @@ async function postMigrate(driver) {
 	const tracer = getTracer("db.postMigrate");
 	await startActiveSpan(tracer, "db.postMigrate", async () => {
 		await driver.execute(`INSERT INTO "${VERSION}"."status" ("code") VALUES ('${Status.VALID}'), ('${Status.SIMULATION_ERROR}') ON CONFLICT DO NOTHING;`);
-		await driver.execute(`INSERT INTO "${VERSION}"."position_types" ("type") VALUES ('${Type.ERC20}'), ('${Type.VAULT_V1}') ON CONFLICT DO NOTHING;`);
+		await driver.execute(`INSERT INTO "${VERSION}"."position_types" ("type") VALUES ('${Type.ERC20}'), ('${Type.VAULT_V1}'), ('${Type.DEBT_OF}'), ('${Type.COLLATERAL_OF}') ON CONFLICT DO NOTHING;`);
 		await driver.execute(`
     CREATE OR REPLACE FUNCTION apply_group_consumed_stmt_ins()
     RETURNS trigger
@@ -9599,19 +10593,23 @@ async function postMigrate(driver) {
     BEGIN
       DELETE FROM "${VERSION}"."positions" p
       USING (
-        SELECT DISTINCT c.position_chain_id, c.position_contract, c.position_user
+        SELECT DISTINCT c.position_chain_id, c.position_contract, c.position_user, c.position_type_id
         FROM deleted_rows d
         JOIN "${VERSION}"."callbacks" c ON c.id = d.callback_id
       ) AS affected
+      JOIN "${VERSION}"."position_types" pt ON pt.id = affected.position_type_id
       WHERE p.chain_id = affected.position_chain_id
         AND p.contract = affected.position_contract
         AND p."user" = affected.position_user
+        AND p.position_type_id = affected.position_type_id
+        AND pt.type = 'erc20'
         AND NOT EXISTS (
           SELECT 1 FROM "${VERSION}"."callbacks" c2
           JOIN "${VERSION}"."offers_callbacks" oc ON oc.callback_id = c2.id
           WHERE c2.position_chain_id = p.chain_id
             AND c2.position_contract = p.contract
             AND c2.position_user = p."user"
+            AND c2.position_type_id = p.position_type_id
         );
       RETURN NULL;
     END;
@@ -9658,7 +10656,7 @@ async function postMigrate(driver) {
     RETURNS TRIGGER AS $$
     DECLARE
       orphan_obligation_ids TEXT[];
-      candidate_oracles RECORD;
+      orphan_obligation_keys TEXT[];
     BEGIN
       -- 1. Find orphan obligation IDs
       SELECT ARRAY_AGG(DISTINCT obligation_id) INTO orphan_obligation_ids
@@ -9666,33 +10664,39 @@ async function postMigrate(driver) {
       WHERE NOT EXISTS (
         SELECT 1 FROM "${VERSION}"."offers" ov
         WHERE ov.obligation_id = d.obligation_id
+      )
+      AND NOT EXISTS (
+        SELECT 1 FROM "${VERSION}"."positions" p
+        JOIN "${VERSION}"."position_types" pt ON pt.id = p.position_type_id
+        WHERE p."contract" = d.obligation_id
+          AND pt.type IN ('debtOf', 'collateralOf')
       );
 
-      -- 2. If no orphan obligations, exit early
+      -- 2. If no orphan obligation IDs, exit early
       IF orphan_obligation_ids IS NULL OR array_length(orphan_obligation_ids, 1) IS NULL THEN
         RETURN NULL;
       END IF;
 
-      -- 3. Capture candidate oracles (from collaterals of orphan obligations)
-      CREATE TEMP TABLE _candidate_oracles ON COMMIT DROP AS
-      SELECT DISTINCT oc.oracle_chain_id, oc.oracle_address
-      FROM "${VERSION}"."obligation_collaterals_v2" oc
-      WHERE oc.obligation_id = ANY(orphan_obligation_ids);
+      -- 3. Delete orphan obligation id keys
+      DELETE FROM "${VERSION}"."obligation_id_keys" oia
+      WHERE oia.obligation_id = ANY(orphan_obligation_ids);
 
-      -- 4. Delete orphan obligations (cascades to collaterals)
-      DELETE FROM "${VERSION}"."obligations" ob
-      WHERE ob.obligation_id = ANY(orphan_obligation_ids);
+      -- 4. Find canonical obligation keys with no remaining obligation id keys
+      SELECT ARRAY_AGG(ob.obligation_key) INTO orphan_obligation_keys
+      FROM "${VERSION}"."obligations" ob
+      WHERE NOT EXISTS (
+        SELECT 1 FROM "${VERSION}"."obligation_id_keys" oia
+        WHERE oia.obligation_key = ob.obligation_key
+      );
 
-      -- 5. Delete oracles that are now orphaned (no remaining collateral references)
-      DELETE FROM "${VERSION}"."oracles" o
-      USING _candidate_oracles co
-      WHERE o.chain_id = co.oracle_chain_id
-        AND o.address = co.oracle_address
-        AND NOT EXISTS (
-          SELECT 1 FROM "${VERSION}"."obligation_collaterals_v2" oc
-          WHERE oc.oracle_chain_id = o.chain_id
-            AND oc.oracle_address = o.address
-        );
+      -- 5. If no orphan canonical obligations, exit early
+      IF orphan_obligation_keys IS NULL OR array_length(orphan_obligation_keys, 1) IS NULL THEN
+        RETURN NULL;
+      END IF;
+
+      -- 6. Delete orphan canonical obligations (cascades to collaterals)
+      DELETE FROM "${VERSION}"."obligations" ob
+      WHERE ob.obligation_key = ANY(orphan_obligation_keys);
 
       RETURN NULL;
     END;
@@ -9710,16 +10714,21 @@ async function postMigrate(driver) {
     RETURNS trigger
     LANGUAGE plpgsql AS $$
     BEGIN
-      INSERT INTO "${VERSION}"."offsets" (chain_id, "user", contract, "group", obligation_id, value)
-      VALUES (
-        OLD.chain_id,
-        OLD."user",
-        OLD.contract,
-        OLD."group",
-        OLD.obligation_id,
-        OLD.upper::numeric - OLD.lower::numeric
-      )
-      ON CONFLICT (chain_id, "user", contract, "group", obligation_id) DO NOTHING;
+      BEGIN
+        INSERT INTO "${VERSION}"."offsets" (chain_id, "user", contract, "group", obligation_id, value)
+        VALUES (
+          OLD.chain_id,
+          OLD."user",
+          OLD.contract,
+          OLD."group",
+          OLD.obligation_id,
+          OLD.upper::numeric - OLD.lower::numeric
+        )
+        ON CONFLICT (chain_id, "user", contract, "group", obligation_id) DO NOTHING;
+      EXCEPTION WHEN foreign_key_violation THEN
+        -- lots_positions may be gone during cascaded deletes
+        NULL;
+      END;
       RETURN OLD;
     END;
     $$;
@@ -9742,11 +10751,26 @@ async function postMigrate(driver) {
           AND l.contract = OLD.contract
           AND l."user" = OLD."user"
       ) THEN
-        -- No lots remain, delete the position (cascades to offsets)
+        -- No lots remain, delete erc20 positions and their lots_positions bridge rows.
+        -- debtOf/collateralOf positions live independently of offers and must not be deleted here.
+        -- First delete the position (for ERC20, asset = contract).
         DELETE FROM "${VERSION}"."positions" p
-        WHERE p.chain_id = OLD.chain_id
-          AND p.contract = OLD.contract
-          AND p."user" = OLD."user";
+        USING "${VERSION}"."lots_positions" lp
+        JOIN "${VERSION}"."position_types" pt ON pt.id = lp.position_type_id
+        WHERE lp.chain_id = OLD.chain_id
+          AND lp.contract = OLD.contract
+          AND lp."user" = OLD."user"
+          AND p.chain_id = lp.chain_id
+          AND p.contract = lp.contract
+          AND p."user" = lp."user"
+          AND p.position_type_id = lp.position_type_id
+          AND pt.type = 'erc20';
+
+        -- Delete the lots_positions bridge row (cascades to offsets via offsets_lots_positions_fk).
+        DELETE FROM "${VERSION}"."lots_positions" lp
+        WHERE lp.chain_id = OLD.chain_id
+          AND lp.contract = OLD.contract
+          AND lp."user" = OLD."user";
       END IF;
       RETURN NULL;
     END;
@@ -9846,7 +10870,7 @@ function resolveRouterConfig(config, env) {
 		const override = config.chains[name];
 		if (!override) throw new Error(`Chain ${name} is missing configuration.`);
 		const rpcUrl = resolveRpcUrl(name, override, env, indexerChains.includes(name));
-		const chainWithContracts = applyChainOverride(chains$2[name], override);
+		const chainWithContracts = applyChainOverride(chains$1[name], override);
 		acc[name] = {
 			chain: rpcUrl ? applyRpcUrlOverride(chainWithContracts, rpcUrl) : chainWithContracts,
 			rpcUrl
@@ -9955,7 +10979,7 @@ function resolveRpcUrls(baseChain, rpcUrl) {
 function createDefaultConfig() {
 	const chainName = "ethereum-virtual-testnet";
 	const rpcUrl = "https://virtual.mainnet.eu.rpc.tenderly.co/49383bba-e2c5-423e-bc94-8e78c91f1130";
-	const baseChain = chains$2[chainName];
+	const baseChain = chains$1[chainName];
 	const chainWithRpc = applyRpcUrlOverride(baseChain, rpcUrl);
 	const chain = {
 		...chainWithRpc,
@@ -10067,7 +11091,10 @@ const gatekeeperCmd = new RouterCmd("gatekeeper");
 gatekeeperCmd.description("Start Gatekeeper validation service.").action(async (opts) => {
 	const { gatekeeper: gatekeeperConfig, chainRegistry, logger } = opts;
 	await runWithLogger(logger, async () => {
-		const gatekeeperCore = create$21({ rules: morphoRules(chainRegistry.list()) });
+		const gatekeeperCore = create$21({ rules: (chainId) => morphoRules({
+			chains: chainRegistry.list(),
+			chainId
+		}) });
 		const handle = await start$1({
 			gatekeeper: gatekeeperCore,
 			chainRegistry,
@@ -10551,7 +11578,7 @@ async function getObligation(params, db) {
 		if (listing.obligations.length === 0) return failure(new NotFoundError("Obligation not found"));
 		const obligation = listing.obligations[0];
 		return success({
-			data: from$5(obligation.obligation, obligation.quote),
+			data: from$5(obligation.obligation, obligation.quote, obligation.chainId),
 			cursor: null
 		});
 	} catch (err) {
@@ -10592,7 +11619,7 @@ async function getObligations(queryParameters, db) {
 			limit: query.limit
 		});
 		return success({
-			data: listing.obligations.map((item) => from$5(item.obligation, item.quote)),
+			data: listing.obligations.map((item) => from$5(item.obligation, item.quote, item.chainId)),
 			cursor: listing.nextCursor
 		});
 	} catch (err) {
@@ -10617,23 +11644,20 @@ async function getObligations(queryParameters, db) {
 */
 async function getOffersQuery(db, parameters) {
 	const limit = parameters?.limit ?? DEFAULT_LIMIT$3;
-	const cursor = parameters?.cursor;
+	const rawCursor = parameters?.cursor;
 	const maker = parameters?.maker;
-	if (cursor !== null && cursor !== void 0) {
-		if (!cursor.startsWith("0x") || cursor.length !== 66) throw new Error("Invalid cursor format");
-	}
+	const cursor = maker && rawCursor !== void 0 && rawCursor !== null ? parseMakerCursor(rawCursor) : void 0;
 	const now = Math.floor((Date.now() - 1) / 1e3);
 	const collateralsLateral = db.select({ collaterals: sql`COALESCE(
         jsonb_agg(
           jsonb_build_object(
             'asset', ${obligationCollateralsV2.asset},
-            'oracle', ${oracles.address},
+            'oracle', ${obligationCollateralsV2.oracleAddress},
             'lltv', ${obligationCollateralsV2.lltv}
           )
         ),
         '[]'::jsonb
-      )`.as("collaterals") }).from(obligationCollateralsV2).innerJoin(oracles, sql`${obligationCollateralsV2.oracleChainId} = ${oracles.chainId}
-             AND ${obligationCollateralsV2.oracleAddress} = ${oracles.address}`).where(eq(obligationCollateralsV2.obligationId, offers.obligationId)).as("collaterals_lateral");
+      )`.as("collaterals") }).from(obligationCollateralsV2).where(eq(obligationCollateralsV2.obligationKey, obligationIdKeys.obligationKey)).as("collaterals_lateral");
 	const lotBalanceExpr = sql`GREATEST(0, LEAST(
       COALESCE(${positions.balance}, 0)::numeric
         + COALESCE((
@@ -10678,6 +11702,7 @@ async function getOffersQuery(db, parameters) {
           AND LOWER(${lots.user}) = LOWER(${callbacks.positionUser})
           AND LOWER(${lots.group}) = LOWER(${offers.group})
         WHERE ${offersCallbacks.offerHash} = ${offers.hash}
+          AND ${offersCallbacks.obligationId} = ${offers.obligationId}
         ORDER BY
           ${callbacks.positionChainId},
           LOWER(${callbacks.positionContract}),
@@ -10687,6 +11712,7 @@ async function getOffersQuery(db, parameters) {
     ), 0)`;
 	const rows = (await db.select({
 		hash: offers.hash,
+		obligationId: offers.obligationId,
 		maker: offers.groupMaker,
 		assets: offers.assets,
 		obligationUnits: offers.obligationUnits,
@@ -10699,7 +11725,7 @@ async function getOffersQuery(db, parameters) {
 		group: offers.group,
 		session: offers.session,
 		buy: offers.buy,
-		chainId: obligations.chainId,
+		chainId: obligationIdKeys.chainId,
 		loanToken: obligations.loanToken,
 		callbackAddress: offers.callbackAddress,
 		callbackData: offers.callbackData,
@@ -10716,7 +11742,7 @@ async function getOffersQuery(db, parameters) {
               )
             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`).where(and(cursor !== null && cursor !== void 0 ? gt(offers.hash, cursor) : void 0, maker !== void 0 ? eq(offers.groupMaker, maker.toLowerCase()) : void 0, gte(offers.expiry, now), gte(offers.maturity, now), maker === void 0 ? sql`GREATEST(0,
+	}).from(offers).innerJoin(obligationIdKeys, eq(offers.obligationId, obligationIdKeys.obligationId)).innerJoin(obligations, eq(obligationIdKeys.obligationKey, obligations.obligationKey)).innerJoin(groups, and(eq(offers.groupChainId, groups.chainId), eq(offers.groupMaker, groups.maker), eq(offers.group, groups.group))).innerJoinLateral(collateralsLateral, sql`true`).where(and(cursor !== void 0 ? cursor.obligationId === void 0 ? gt(offers.hash, cursor.hash) : or(gt(offers.hash, cursor.hash), and(eq(offers.hash, cursor.hash), gt(offers.obligationId, cursor.obligationId))) : 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(
@@ -10724,10 +11750,11 @@ async function getOffersQuery(db, parameters) {
                       ${availableExpr}::numeric
                     )
                   END
-                ) > 0` : void 0)).orderBy(asc(offers.hash)).limit(limit)).map((row) => {
+                ) > 0` : void 0)).orderBy(asc(offers.hash), asc(offers.obligationId)).limit(limit)).map((row) => {
 		const receiverIfMakerIsSeller = (row.receiverIfMakerIsSeller ?? row.maker).toLowerCase();
 		return {
 			hash: row.hash,
+			obligationId: row.obligationId,
 			maker: row.maker,
 			assets: BigInt(row.assets),
 			obligationUnits: BigInt(row.obligationUnits),
@@ -10759,7 +11786,7 @@ async function getOffersQuery(db, parameters) {
 	});
 	return {
 		rows,
-		nextCursor: rows.length === limit ? rows[rows.length - 1].hash : null
+		nextCursor: rows.length === limit ? maker === void 0 ? rows[rows.length - 1].hash : formatOfferCursor(rows[rows.length - 1]) : null
 	};
 }
 async function getOffers(queryParameters, db) {
@@ -10778,12 +11805,18 @@ async function getOffers(queryParameters, db) {
 			cursor: query.cursor,
 			limit: query.limit
 		});
-		const hashes = rows.map((row) => row.hash);
-		const attestationMap = await db.trees.getAttestations(hashes);
+		const offers = rows.map((row) => ({
+			offerHash: row.hash,
+			obligationId: row.obligationId
+		}));
+		const attestationMap = await db.trees.getAttestations(offers);
 		return success({
 			data: rows.map((row) => {
-				const hash$1 = hash(row);
-				const attestation = attestationMap.get(hash$1);
+				const key = toAttestationKey({
+					offerHash: row.hash,
+					obligationId: row.obligationId
+				});
+				const attestation = attestationMap.get(key);
 				return from$4({
 					...row,
 					...attestation
@@ -10801,6 +11834,19 @@ async function getOffers(queryParameters, db) {
 		return failure(err);
 	}
 }
+function parseMakerCursor(cursor) {
+	const [rawHash, rawObligationId, ...tail] = cursor.split(":");
+	if (tail.length > 0) throw new Error("Invalid cursor format");
+	if (!rawHash || !rawObligationId || !HEX_32.test(rawHash) || !HEX_32.test(rawObligationId)) throw new Error("Invalid cursor format");
+	return {
+		hash: rawHash.toLowerCase(),
+		obligationId: rawObligationId.toLowerCase()
+	};
+}
+function formatOfferCursor(row) {
+	return `${row.hash.toLowerCase()}:${row.obligationId.toLowerCase()}`;
+}
+const HEX_32 = /^0x[a-fA-F0-9]{64}$/;
 
 //#endregion
 //#region src/api/Controllers/getUserPositions.ts
@@ -11005,8 +12051,12 @@ function createHttpClient(config) {
 			body: json
 		};
 	};
-	const isAllowed = async (offers) => {
-		const { statusCode, body } = await validate({ offers: offers.map((offer) => toSnakeCase(offer)) });
+	const isAllowed = async (parameters) => {
+		const { offers, chainId } = parameters;
+		const { statusCode, body } = await validate({
+			chain_id: chainId,
+			offers: offers.map((offer) => toSnakeCase(offer))
+		});
 		if (statusCode !== 200) {
 			const errorMessage = extractErrorMessage(body);
 			throw new Error(`Gatekeeper validation failed: ${errorMessage ?? `status ${statusCode}`}`);
@@ -11064,7 +12114,10 @@ startCmd.description("Start Router services.").addOption(new Option("--mock <n>"
 		let gatekeeperUrl = gatekeeperConfig?.url;
 		let gatekeeperHandle = null;
 		if (!gatekeeperUrl) {
-			const gatekeeperCore = create$21({ rules: morphoRules(chainRegistry.list()) });
+			const gatekeeperCore = create$21({ rules: (chainId) => morphoRules({
+				chains: chainRegistry.list(),
+				chainId
+			}) });
 			gatekeeperHandle = await start$1({
 				gatekeeper: gatekeeperCore,
 				chainRegistry,
@@ -11096,17 +12149,23 @@ startCmd.description("Start Router services.").addOption(new Option("--mock <n>"
 		}
 		if (file) {
 			const offers = await getOffersFromFile(file);
+			const offersOnChain = withSingleChainContext({
+				offers,
+				chainRegistry
+			});
 			const offerBlockNumber = 1;
 			const positionBlockNumber = offerBlockNumber + 1;
 			await seedOffers({
 				db,
-				offers,
+				chainRegistry,
+				offers: offersOnChain,
 				blockNumber: offerBlockNumber
 			});
 			await seedOfferAssociations({
 				db,
+				chainRegistry,
 				gatekeeper,
-				offers,
+				offers: offersOnChain,
 				blockNumber: positionBlockNumber
 			});
 			logger.info({
@@ -11203,7 +12262,7 @@ async function seedMockOffers(parameters) {
 	const expiry = now + 3600;
 	const maturity = from$16("end_of_next_month");
 	const oraclePrice = 10n ** 36n;
-	const offers = createMockOffers({
+	const offersOnChain = createMockOffers({
 		count,
 		chains: configuredChains,
 		assetsByChainId,
@@ -11216,23 +12275,35 @@ async function seedMockOffers(parameters) {
 	});
 	await seedOffers({
 		db,
-		offers,
+		chainRegistry,
+		offers: offersOnChain,
 		blockNumber: offerBlockNumber
 	});
-	await db.oracles.upsert(seedMockOracles(offers, oraclePrice, positionBlockNumber));
+	await db.oracles.upsert(seedMockOracles(offersOnChain, oraclePrice, positionBlockNumber));
 	await seedOfferAssociations({
 		db,
+		chainRegistry,
 		gatekeeper,
-		offers,
+		offers: offersOnChain,
 		blockNumber: positionBlockNumber
 	});
-	return offers;
+	return offersOnChain.map((entry) => entry.offer);
 }
 async function getOffersFromFile(filePath) {
 	const content = await readFile(filePath, "utf-8");
 	const data = JSON.parse(content);
 	return Array.isArray(data) ? data.map(from$12) : [from$12(data)];
 }
+function withSingleChainContext(parameters) {
+	const { offers, chainRegistry } = parameters;
+	const chains = chainRegistry.list();
+	if (chains.length !== 1) throw new Error(`Offer files require exactly one configured chain because offers are chain-agnostic. Found ${chains.length}.`);
+	const chainId = chains[0].id;
+	return offers.map((offer) => ({
+		offer,
+		chainId
+	}));
+}
 function createMockOffers(parameters) {
 	const { count, chains, assetsByChainId, oraclesByChainId, assetsDecimals, start, expiry, maturity, chainRegistry } = parameters;
 	if (chains.length === 0) throw new Error("No chains configured for mock offers");
@@ -11243,7 +12314,6 @@ function createMockOffers(parameters) {
 		if (allowedAssets.length === 0) throw new Error(`No allowed assets configured for chain ${chain.id}`);
 		const loanToken = allowedAssets[Math.floor(Math.random() * allowedAssets.length)];
 		const offer = random({
-			chains: [chain],
 			loanTokens: [loanToken],
 			assetsDecimals,
 			start,
@@ -11270,25 +12340,28 @@ function createMockOffers(parameters) {
 			oracle: allowedOracles[Math.floor(Math.random() * allowedOracles.length)],
 			lltv
 		}));
-		if (!chainRegistry.getById(offer.chainId)) throw new Error(`Missing chain config for id ${offer.chainId}`);
-		return from$12({
-			...offer,
-			loanToken,
-			collaterals,
-			callback: {
-				address: zeroAddress,
-				data: "0x"
-			}
-		});
+		if (!chainRegistry.getById(chain.id)) throw new Error(`Missing chain config for id ${chain.id}`);
+		return {
+			chainId: chain.id,
+			offer: from$12({
+				...offer,
+				loanToken,
+				collaterals,
+				callback: {
+					address: zeroAddress,
+					data: "0x"
+				}
+			})
+		};
 	});
 }
 function seedMockOracles(offers, price, blockNumber) {
 	const oracleMap = /* @__PURE__ */ new Map();
-	for (const offer of offers) for (const collateral of offer.collaterals) {
-		const key = `${offer.chainId}-${collateral.oracle}`.toLowerCase();
+	for (const { offer, chainId } of offers) for (const collateral of offer.collaterals) {
+		const key = `${chainId}-${collateral.oracle}`.toLowerCase();
 		if (oracleMap.has(key)) continue;
 		oracleMap.set(key, from$11({
-			chainId: offer.chainId,
+			chainId,
 			address: collateral.oracle,
 			price: price.toString(),
 			blockNumber
@@ -11297,56 +12370,75 @@ function seedMockOracles(offers, price, blockNumber) {
 	return Array.from(oracleMap.values());
 }
 async function seedOffers(parameters) {
-	const { db, offers, blockNumber } = parameters;
+	const { db, chainRegistry, offers, blockNumber } = parameters;
 	if (offers.length === 0) return;
 	const dependencies = buildOfferDependencies({
 		offers,
-		blockNumber
+		blockNumber,
+		chainRegistry
 	});
 	await db.oracles.upsert(dependencies.oracles);
 	await db.obligations.create(dependencies.obligations);
 	await db.groups.create(dependencies.groups);
 	await db.offers.create([{
 		blockNumber,
-		offers
+		offers: dependencies.offers
 	}]);
 }
 async function seedOfferAssociations(parameters) {
-	const { db, offers, blockNumber } = parameters;
+	const { db, chainRegistry, offers, blockNumber } = parameters;
 	if (offers.length === 0) return;
 	const { callbacks, positions, lots } = buildOfferAssociationsFromOffers({
 		offers,
-		blockNumber
+		blockNumber,
+		chainRegistry
 	});
 	if (positions.length > 0) await db.positions.upsert(positions);
 	if (callbacks.length > 0) await db.callbacks.upsert(callbacks);
 	if (lots.length > 0) await db.lots.create(lots);
 }
 function buildOfferDependencies(parameters) {
-	const { offers, blockNumber } = parameters;
+	const { offers, blockNumber, chainRegistry } = parameters;
 	const obligationsById = /* @__PURE__ */ new Map();
+	const offersWithIds = [];
 	const oraclesByKey = /* @__PURE__ */ new Map();
 	const groupsByKey = /* @__PURE__ */ new Map();
-	for (const offer of offers) {
-		const obligationId$1 = obligationId(offer);
-		if (!obligationsById.get(obligationId$1)) obligationsById.set(obligationId$1, from$13({
-			chainId: offer.chainId,
-			loanToken: offer.loanToken,
-			maturity: offer.maturity,
-			collaterals: offer.collaterals
-		}));
+	for (const { offer, chainId } of offers) {
+		const morphoV2 = resolveMorphoV2Address({
+			chainRegistry,
+			chainId
+		});
+		const obligationId$2 = obligationId(offer, {
+			chainId,
+			morphoV2
+		});
+		offersWithIds.push({
+			offer,
+			obligationId: obligationId$2,
+			chainId
+		});
+		if (!obligationsById.get(obligationId$2)) obligationsById.set(obligationId$2, {
+			obligationId: obligationId$2,
+			chainId,
+			morphoV2,
+			obligation: from$13({
+				loanToken: offer.loanToken,
+				maturity: offer.maturity,
+				collaterals: offer.collaterals
+			})
+		});
 		for (const collateral of offer.collaterals) {
-			const oracleKey = `${offer.chainId}-${collateral.oracle}`.toLowerCase();
+			const oracleKey = `${chainId}-${collateral.oracle}`.toLowerCase();
 			if (!oraclesByKey.has(oracleKey)) oraclesByKey.set(oracleKey, from$11({
-				chainId: offer.chainId,
+				chainId,
 				address: collateral.oracle,
 				price: null,
 				blockNumber
 			}));
 		}
-		const groupKey = `${offer.chainId}-${offer.maker}-${offer.group}`.toLowerCase();
+		const groupKey = `${chainId}-${offer.maker}-${offer.group}`.toLowerCase();
 		if (!groupsByKey.has(groupKey)) groupsByKey.set(groupKey, {
-			chainId: offer.chainId,
+			chainId,
 			maker: offer.maker,
 			group: offer.group,
 			blockNumber
@@ -11354,21 +12446,31 @@ function buildOfferDependencies(parameters) {
 	}
 	return {
 		obligations: Array.from(obligationsById.values()),
+		offers: offersWithIds,
 		oracles: Array.from(oraclesByKey.values()),
 		groups: Array.from(groupsByKey.values())
 	};
 }
 function buildOfferAssociationsFromOffers(parameters) {
-	const { offers, blockNumber } = parameters;
+	const { offers, blockNumber, chainRegistry } = parameters;
+	const erc20TypeId = Object.values(Type).indexOf(Type.ERC20) + 1;
 	const callbacks = [];
 	const positions = [];
 	const lots = [];
-	for (const offer of offers) {
+	for (const { offer, chainId } of offers) {
 		if (!offer.buy) continue;
+		const morphoV2 = resolveMorphoV2Address({
+			chainRegistry,
+			chainId
+		});
 		const loanToken = offer.loanToken.toLowerCase();
 		const offerHash = hash(offer);
+		const obligationId$1 = obligationId(offer, {
+			chainId,
+			morphoV2
+		});
 		positions.push(from$10({
-			chainId: offer.chainId,
+			chainId,
 			contract: loanToken,
 			user: offer.maker,
 			type: Type.ERC20,
@@ -11378,19 +12480,22 @@ function buildOfferAssociationsFromOffers(parameters) {
 		}));
 		callbacks.push({
 			offerHash,
+			obligationId: obligationId$1,
 			callbacks: [{
-				chainId: offer.chainId,
+				chainId,
 				contract: loanToken,
 				user: offer.maker,
-				amount: offer.assets
+				amount: offer.assets,
+				positionTypeId: erc20TypeId
 			}]
 		});
 		lots.push({
-			positionChainId: offer.chainId,
+			positionChainId: chainId,
 			positionContract: loanToken,
 			positionUser: offer.maker,
+			positionTypeId: erc20TypeId,
 			group: offer.group,
-			obligationId: obligationId(offer),
+			obligationId: obligationId$1,
 			size: offer.assets
 		});
 	}
@@ -11400,6 +12505,13 @@ function buildOfferAssociationsFromOffers(parameters) {
 		lots
 	};
 }
+function resolveMorphoV2Address(parameters) {
+	const chain = parameters.chainRegistry.getById(parameters.chainId);
+	if (!chain) throw new Error(`Missing chain configuration for chain ${parameters.chainId}.`);
+	const morphoV2 = chain.custom.morpho.address.toLowerCase();
+	if (morphoV2 === zeroAddress) throw new Error(`Morpho V2 address is zero for chain ${parameters.chainId}.`);
+	return morphoV2;
+}
 
 //#endregion
 //#region src/cli/cli.ts