@morpho-dev/router 0.9.0 → 0.10.0

package/dist/index.node.mjs

@@ -1,7 +1,7 @@
 import { t as __exportAll } from "./chunk-Bo1DHCg-.mjs";
 import { getBlock, getBlockNumber, getLogs, multicall } from "viem/actions";
 import { AsyncLocalStorage } from "node:async_hooks";
-import { bytesToHex, decodeAbiParameters, encodeAbiParameters, erc20Abi, getAddress, hashTypedData, hexToBytes, isAddress, isHex, keccak256, maxUint256, numberToHex, pad, parseAbi, parseEventLogs, publicActions, recoverAddress, stringify, zeroAddress } from "viem";
+import { bytesToHex, concatHex, decodeAbiParameters, encodeAbiParameters, erc20Abi, getAddress, hashTypedData, hexToBytes, isAddress, isHex, keccak256, maxUint256, numberToHex, pad, parseAbi, parseEventLogs, publicActions, recoverAddress, stringify, zeroAddress } from "viem";
 import { SpanStatusCode, trace } from "@opentelemetry/api";
 import "@opentelemetry/exporter-trace-otlp-proto";
 import "@opentelemetry/id-generator-aws-xray";
@@ -12,7 +12,7 @@ import "@opentelemetry/propagator-aws-xray";
 import "@opentelemetry/resources";
 import "@opentelemetry/sdk-trace-node";
 import "@opentelemetry/semantic-conventions";
-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 { anvil, base, mainnet } from "viem/chains";
 import * as z$1 from "zod";
 import { StandardMerkleTree } from "@openzeppelin/merkle-tree";
@@ -802,7 +802,7 @@ const reconcile = async (parameters) => {
 //#region src/indexer/collectors/Collector.ts
 const names = [
 	"offers",
-	"consumed_events",
+	"morpho_v2",
 	"positions",
 	"prices"
 ];
@@ -1179,7 +1179,7 @@ var Chain_exports = /* @__PURE__ */ __exportAll({
 	MissingBlockNumberError: () => MissingBlockNumberError,
 	chainIds: () => chainIds,
 	chainNames: () => chainNames,
-	chains: () => chains$2,
+	chains: () => chains$1,
 	getChain: () => getChain,
 	getWhitelistedChains: () => getWhitelistedChains,
 	streamLogs: () => streamLogs
@@ -1196,17 +1196,17 @@ const chainNameLookup = new Map(Object.entries(ChainId).map(([key, value]) => [v
 function getChain(chainId) {
 	const chainName = chainNameLookup.get(chainId);
 	if (!chainName) return void 0;
-	return chains$2[chainName];
+	return chains$1[chainName];
 }
 const getWhitelistedChains = () => {
 	return [
-		chains$2.ethereum,
-		chains$2.base,
-		chains$2["ethereum-virtual-testnet"],
-		chains$2.anvil
+		chains$1.ethereum,
+		chains$1.base,
+		chains$1["ethereum-virtual-testnet"],
+		chains$1.anvil
 	];
 };
-const chains$2 = {
+const chains$1 = {
 	ethereum: {
 		...mainnet,
 		id: ChainId.ETHEREUM,
@@ -1243,16 +1243,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: {
@@ -1576,9 +1576,24 @@ const LLTVSchema = z$1.bigint({ coerce: true }).refine((lltv) => {
 var Collateral_exports = /* @__PURE__ */ __exportAll({
 	CollateralSchema: () => CollateralSchema,
 	CollateralsSchema: () => CollateralsSchema,
+	abi: () => abi$1,
 	from: () => from$17,
 	random: () => random$3
 });
+const abi$1 = [
+	{
+		type: "address",
+		name: "token"
+	},
+	{
+		type: "uint256",
+		name: "lltv"
+	},
+	{
+		type: "address",
+		name: "oracle"
+	}
+];
 const CollateralSchema = z$1.object({
 	asset: z$1.string().transform(transformAddress),
 	oracle: z$1.string().transform(transformAddress),
@@ -1683,80 +1698,6 @@ var DenominatorIsZeroError = class extends BaseError {
 	}
 };
 
-//#endregion
-//#region src/core/Liquidity.ts
-var Liquidity_exports = /* @__PURE__ */ __exportAll({
-	calculateMaxDebt: () => calculateMaxDebt,
-	generateAllowancePoolId: () => generateAllowancePoolId,
-	generateBalancePoolId: () => generateBalancePoolId,
-	generateDebtPoolId: () => generateDebtPoolId,
-	generateMarketLiquidityPoolId: () => generateMarketLiquidityPoolId,
-	generateObligationCollateralPoolId: () => generateObligationCollateralPoolId,
-	generateUserVaultPositionPoolId: () => generateUserVaultPositionPoolId,
-	generateVaultPositionPoolId: () => generateVaultPositionPoolId
-});
-/**
-* Calculate maximum debt capacity from collateral amount.
-* @param amount - Collateral amount
-* @param oraclePrice - Oracle price (scaled to 36 decimals)
-* @param lltv - Loan-to-value ratio (scaled to 18 decimals)
-* @returns Maximum debt capacity
-*/
-function calculateMaxDebt(amount, oraclePrice, lltv) {
-	return amount * oraclePrice / 10n ** 36n * lltv / 10n ** 18n;
-}
-/**
-* Generate pool ID for balance pools.
-*/
-function generateBalancePoolId(parameters) {
-	const { user, chainId, token } = parameters;
-	return `${user}-${chainId.toString()}-${token}-balance`.toLowerCase();
-}
-/**
-* Generate pool ID for allowance pools.
-*/
-function generateAllowancePoolId(parameters) {
-	const { user, chainId, token } = parameters;
-	return `${user}-${chainId.toString()}-${token}-allowance`.toLowerCase();
-}
-/**
-* Generate pool ID for obligation collateral pools.
-* Obligation collateral pools represent collateral already deposited in the obligation.
-* These pools are shared across all offers with the same obligation.
-*/
-function generateObligationCollateralPoolId(parameters) {
-	const { user, chainId, obligationId, token } = parameters;
-	return `${user}-${chainId.toString()}-${obligationId}-${token}-obligation-collateral`.toLowerCase();
-}
-/**
-* Generate pool ID for debt pools.
-*/
-function generateDebtPoolId(parameters) {
-	const { user, chainId, obligationId } = parameters;
-	return `${user}-${chainId.toString()}-${obligationId}-debt`.toLowerCase();
-}
-/**
-* Generate pool ID for user position in a vault.
-*/
-function generateUserVaultPositionPoolId(parameters) {
-	const { user, chainId, vault } = parameters;
-	return `${user}-${chainId.toString()}-${vault}-user-vault-position`.toLowerCase();
-}
-/**
-* Generate pool ID for vault position in a market.
-*/
-function generateVaultPositionPoolId(parameters) {
-	const { vault, chainId, marketId } = parameters;
-	return `${vault}-${chainId.toString()}-${marketId}-vault-position`.toLowerCase();
-}
-/**
-* Generate pool ID for market total liquidity.
-*/
-function generateMarketLiquidityPoolId(parameters) {
-	const { chainId, marketId } = parameters;
-	return `${chainId.toString()}-${marketId}-market-liquidity`.toLowerCase();
-}
-
 //#endregion
 //#region src/core/Maturity.ts
 var Maturity_exports = /* @__PURE__ */ __exportAll({
@@ -1889,18 +1830,38 @@ var Obligation_exports = /* @__PURE__ */ __exportAll({
 	CollateralsAreNotSortedError: () => CollateralsAreNotSortedError,
 	InvalidObligationError: () => InvalidObligationError,
 	ObligationSchema: () => ObligationSchema,
+	abi: () => abi,
 	from: () => from$15,
 	fromOffer: () => fromOffer$1,
 	fromSnakeCase: () => fromSnakeCase$2,
-	id: () => id,
-	random: () => random$2
+	key: () => key,
+	random: () => random$2,
+	tupleAbi: () => tupleAbi
 });
 const ObligationSchema = z$1.object({
-	chainId: z$1.number().min(0).max(Number.MAX_SAFE_INTEGER),
 	loanToken: z$1.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
@@ -1911,7 +1872,6 @@ const ObligationSchema = z$1.object({
 * @example
 * ```ts
 * const obligation = Obligation.from({
-*   chainId: 1,
 *   loanToken: privateKeyToAccount(generatePrivateKey()).address,
 *   collaterals: [
 *     Collateral.from({
@@ -1931,7 +1891,6 @@ function from$15(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
@@ -1950,49 +1909,27 @@ function fromSnakeCase$2(input) {
 	return from$15(fromSnakeCase$3(input));
 }
 /**
-* 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(),
@@ -2013,7 +1950,6 @@ function id(parameters) {
 */
 function random$2() {
 	return from$15({
-		chainId: 1,
 		loanToken: address(),
 		collaterals: [random$3()],
 		maturity: from$16("end_of_next_quarter")
@@ -2028,7 +1964,6 @@ function random$2() {
 */
 function fromOffer$1(offer) {
 	return from$15({
-		chainId: offer.chainId,
 		loanToken: offer.loanToken,
 		collaterals: offer.collaterals,
 		maturity: offer.maturity
@@ -2047,6 +1982,121 @@ var CollateralsAreNotSortedError = class extends BaseError {
 	}
 };
 
+//#endregion
+//#region src/core/Id.ts
+var Id_exports = /* @__PURE__ */ __exportAll({
+	creationCode: () => creationCode,
+	toId: () => toId
+});
+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/Liquidity.ts
+var Liquidity_exports = /* @__PURE__ */ __exportAll({
+	calculateMaxDebt: () => calculateMaxDebt,
+	generateAllowancePoolId: () => generateAllowancePoolId,
+	generateBalancePoolId: () => generateBalancePoolId,
+	generateDebtPoolId: () => generateDebtPoolId,
+	generateMarketLiquidityPoolId: () => generateMarketLiquidityPoolId,
+	generateObligationCollateralPoolId: () => generateObligationCollateralPoolId,
+	generateUserVaultPositionPoolId: () => generateUserVaultPositionPoolId,
+	generateVaultPositionPoolId: () => generateVaultPositionPoolId
+});
+/**
+* Calculate maximum debt capacity from collateral amount.
+* @param amount - Collateral amount
+* @param oraclePrice - Oracle price (scaled to 36 decimals)
+* @param lltv - Loan-to-value ratio (scaled to 18 decimals)
+* @returns Maximum debt capacity
+*/
+function calculateMaxDebt(amount, oraclePrice, lltv) {
+	return amount * oraclePrice / 10n ** 36n * lltv / 10n ** 18n;
+}
+/**
+* Generate pool ID for balance pools.
+*/
+function generateBalancePoolId(parameters) {
+	const { user, chainId, token } = parameters;
+	return `${user}-${chainId.toString()}-${token}-balance`.toLowerCase();
+}
+/**
+* Generate pool ID for allowance pools.
+*/
+function generateAllowancePoolId(parameters) {
+	const { user, chainId, token } = parameters;
+	return `${user}-${chainId.toString()}-${token}-allowance`.toLowerCase();
+}
+/**
+* Generate pool ID for obligation collateral pools.
+* Obligation collateral pools represent collateral already deposited in the obligation.
+* These pools are shared across all offers with the same obligation.
+*/
+function generateObligationCollateralPoolId(parameters) {
+	const { user, chainId, obligationId, token } = parameters;
+	return `${user}-${chainId.toString()}-${obligationId}-${token}-obligation-collateral`.toLowerCase();
+}
+/**
+* Generate pool ID for debt pools.
+*/
+function generateDebtPoolId(parameters) {
+	const { user, chainId, obligationId } = parameters;
+	return `${user}-${chainId.toString()}-${obligationId}-debt`.toLowerCase();
+}
+/**
+* Generate pool ID for user position in a vault.
+*/
+function generateUserVaultPositionPoolId(parameters) {
+	const { user, chainId, vault } = parameters;
+	return `${user}-${chainId.toString()}-${vault}-user-vault-position`.toLowerCase();
+}
+/**
+* Generate pool ID for vault position in a market.
+*/
+function generateVaultPositionPoolId(parameters) {
+	const { vault, chainId, marketId } = parameters;
+	return `${vault}-${chainId.toString()}-${marketId}-vault-position`.toLowerCase();
+}
+/**
+* Generate pool ID for market total liquidity.
+*/
+function generateMarketLiquidityPoolId(parameters) {
+	const { chainId, marketId } = parameters;
+	return `${chainId.toString()}-${marketId}-market-liquidity`.toLowerCase();
+}
+
 //#endregion
 //#region src/core/Offer.ts
 var Offer_exports = /* @__PURE__ */ __exportAll({
@@ -2055,17 +2105,19 @@ var Offer_exports = /* @__PURE__ */ __exportAll({
 	Status: () => Status,
 	consumedEvent: () => consumedEvent,
 	decode: () => decode$1,
-	domain: () => domain,
 	encode: () => encode$1,
 	from: () => from$14,
 	fromSnakeCase: () => fromSnakeCase$1,
 	hash: () => hash,
+	liquidateEvent: () => liquidateEvent,
 	obligationId: () => obligationId,
 	random: () => random$1,
+	repayEvent: () => repayEvent,
 	serialize: () => serialize,
+	supplyCollateralEvent: () => supplyCollateralEvent,
 	takeEvent: () => takeEvent,
 	toSnakeCase: () => toSnakeCase,
-	types: () => types
+	withdrawCollateralEvent: () => withdrawCollateralEvent
 });
 /** Internal symbol for caching the computed hash. */
 const HASH_CACHE = Symbol("offer.hash");
@@ -2095,7 +2147,6 @@ const OfferSchema = () => {
 			z$1.bigint()
 		]).optional().default("0x0000000000000000000000000000000000000000000000000000000000000000").transform(transformBytes32),
 		buy: z$1.boolean(),
-		chainId: z$1.number().min(0).max(Number.MAX_SAFE_INTEGER),
 		loanToken: z$1.string().transform(transformAddress),
 		collaterals: CollateralsSchema,
 		callback: z$1.object({
@@ -2164,7 +2215,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,
@@ -2185,7 +2235,6 @@ const serialize = (offer) => ({
 * @returns {Offer} A randomly generated Offer object.
 */
 function random$1(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)];
@@ -2231,7 +2280,6 @@ function random$1(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$3(),
@@ -2251,150 +2299,36 @@ 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$1(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$15({
-		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$15({
+			loanToken: offer.loanToken,
+			collaterals: offer.collaterals,
+			maturity: offer.maturity
+		})
+	});
 }
 const OfferAbi = [
 	{
@@ -2437,10 +2371,6 @@ const OfferAbi = [
 		name: "buy",
 		type: "bool"
 	},
-	{
-		name: "chainId",
-		type: "uint256"
-	},
 	{
 		name: "loanToken",
 		type: "address"
@@ -2495,7 +2425,6 @@ function encode$1(offer) {
 		offer.group,
 		offer.session,
 		offer.buy,
-		BigInt(offer.chainId),
 		offer.loanToken,
 		BigInt(offer.start),
 		offer.collaterals,
@@ -2521,10 +2450,9 @@ function decode$1(data) {
 		group: decoded[7],
 		session: decoded[8],
 		buy: decoded[9],
-		chainId: Number(decoded[10]),
-		loanToken: decoded[11],
-		start: Number(decoded[12]),
-		collaterals: decoded[13].map((c) => {
+		loanToken: decoded[10],
+		start: Number(decoded[11]),
+		collaterals: decoded[12].map((c) => {
 			return from$17({
 				asset: c.asset,
 				oracle: c.oracle,
@@ -2532,23 +2460,145 @@ function decode$1(data) {
 			});
 		}),
 		callback: {
-			address: decoded[14].address,
-			data: decoded[14].data
+			address: decoded[13].address,
+			data: decoded[13].data
+		},
+		receiverIfMakerIsSeller: decoded[14]
+	});
+}
+/**
+* ABI for the Take event emitted by the Morpho V2 contract.
+*/
+const takeEvent = {
+	type: "event",
+	name: "Take",
+	inputs: [
+		{
+			name: "caller",
+			type: "address",
+			indexed: false,
+			internalType: "address"
+		},
+		{
+			name: "id",
+			type: "bytes32",
+			indexed: true,
+			internalType: "bytes32"
+		},
+		{
+			name: "maker",
+			type: "address",
+			indexed: true,
+			internalType: "address"
+		},
+		{
+			name: "taker",
+			type: "address",
+			indexed: true,
+			internalType: "address"
+		},
+		{
+			name: "offerIsBuy",
+			type: "bool",
+			indexed: false,
+			internalType: "bool"
+		},
+		{
+			name: "buyerAssets",
+			type: "uint256",
+			indexed: false,
+			internalType: "uint256"
+		},
+		{
+			name: "sellerAssets",
+			type: "uint256",
+			indexed: false,
+			internalType: "uint256"
+		},
+		{
+			name: "obligationUnits",
+			type: "uint256",
+			indexed: false,
+			internalType: "uint256"
+		},
+		{
+			name: "obligationShares",
+			type: "uint256",
+			indexed: false,
+			internalType: "uint256"
+		},
+		{
+			name: "buyerIsLender",
+			type: "bool",
+			indexed: false,
+			internalType: "bool"
+		},
+		{
+			name: "sellerIsBorrower",
+			type: "bool",
+			indexed: false,
+			internalType: "bool"
+		},
+		{
+			name: "sellerReceiver",
+			type: "address",
+			indexed: false,
+			internalType: "address"
+		},
+		{
+			name: "group",
+			type: "bytes32",
+			indexed: false,
+			internalType: "bytes32"
+		},
+		{
+			name: "consumed",
+			type: "uint256",
+			indexed: false,
+			internalType: "uint256"
+		}
+	],
+	anonymous: false
+};
+/**
+* ABI for the Consume event emitted by the Obligation contract.
+*/
+const consumedEvent = {
+	type: "event",
+	name: "Consume",
+	inputs: [
+		{
+			name: "user",
+			type: "address",
+			indexed: true,
+			internalType: "address"
 		},
-		receiverIfMakerIsSeller: decoded[15]
-	});
-}
+		{
+			name: "group",
+			type: "bytes32",
+			indexed: true,
+			internalType: "bytes32"
+		},
+		{
+			name: "amount",
+			type: "uint256",
+			indexed: false,
+			internalType: "uint256"
+		}
+	],
+	anonymous: false
+};
 /**
-* ABI for the Take event emitted by the Morpho V2 contract.
+* ABI for the Repay event emitted by the MorphoV2 contract.
 */
-const takeEvent = {
+const repayEvent = {
 	type: "event",
-	name: "Take",
+	name: "Repay",
 	inputs: [
 		{
 			name: "caller",
 			type: "address",
-			indexed: false,
+			indexed: true,
 			internalType: "address"
 		},
 		{
@@ -2558,104 +2608,165 @@ const takeEvent = {
 			internalType: "bytes32"
 		},
 		{
-			name: "maker",
+			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: "taker",
+			name: "caller",
 			type: "address",
 			indexed: true,
 			internalType: "address"
 		},
 		{
-			name: "offerIsBuy",
-			type: "bool",
-			indexed: false,
-			internalType: "bool"
+			name: "id",
+			type: "bytes32",
+			indexed: true,
+			internalType: "bytes32"
 		},
 		{
-			name: "buyerAssets",
-			type: "uint256",
+			name: "seizures",
+			type: "tuple[]",
 			indexed: false,
-			internalType: "uint256"
+			internalType: "struct IMorphoV2.Seizure[]",
+			components: [
+				{
+					name: "collateralIndex",
+					type: "uint256",
+					internalType: "uint256"
+				},
+				{
+					name: "repaid",
+					type: "uint256",
+					internalType: "uint256"
+				},
+				{
+					name: "seized",
+					type: "uint256",
+					internalType: "uint256"
+				}
+			]
 		},
 		{
-			name: "sellerAssets",
-			type: "uint256",
-			indexed: false,
-			internalType: "uint256"
+			name: "borrower",
+			type: "address",
+			indexed: true,
+			internalType: "address"
 		},
 		{
-			name: "obligationUnits",
+			name: "totalRepaid",
 			type: "uint256",
 			indexed: false,
 			internalType: "uint256"
 		},
 		{
-			name: "obligationShares",
+			name: "badDebt",
 			type: "uint256",
 			indexed: false,
 			internalType: "uint256"
-		},
-		{
-			name: "buyerIsLender",
-			type: "bool",
-			indexed: false,
-			internalType: "bool"
-		},
-		{
-			name: "sellerIsBorrower",
-			type: "bool",
-			indexed: false,
-			internalType: "bool"
-		},
+		}
+	],
+	anonymous: false
+};
+/**
+* ABI for the SupplyCollateral event emitted by the MorphoV2 contract.
+*/
+const supplyCollateralEvent = {
+	type: "event",
+	name: "SupplyCollateral",
+	inputs: [
 		{
-			name: "sellerReceiver",
+			name: "caller",
 			type: "address",
 			indexed: false,
 			internalType: "address"
 		},
 		{
-			name: "group",
+			name: "id",
 			type: "bytes32",
-			indexed: false,
+			indexed: true,
 			internalType: "bytes32"
 		},
 		{
-			name: "consumed",
+			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 Consume event emitted by the Obligation contract.
+* ABI for the WithdrawCollateral event emitted by the MorphoV2 contract.
 */
-const consumedEvent = {
+const withdrawCollateralEvent = {
 	type: "event",
-	name: "Consume",
+	name: "WithdrawCollateral",
 	inputs: [
 		{
-			name: "user",
+			name: "caller",
 			type: "address",
-			indexed: true,
+			indexed: false,
 			internalType: "address"
 		},
 		{
-			name: "group",
+			name: "id",
 			type: "bytes32",
 			indexed: true,
 			internalType: "bytes32"
 		},
 		{
-			name: "amount",
+			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
@@ -2731,8 +2842,9 @@ function fromCollateral(parameters) {
 * @returns The created oracles. {@link fromOffer.ReturnType}
 */
 function fromOffer(parameters) {
-	const { offer, blockNumber, price = null } = parameters;
+	const { chainId, offer, blockNumber, price = null } = parameters;
 	return fromOffers({
+		chainId,
 		offers: [offer],
 		blockNumber,
 		price
@@ -2746,13 +2858,13 @@ function fromOffer(parameters) {
 * @returns The created oracles. {@link fromOffers.ReturnType}
 */
 function fromOffers(parameters) {
-	const { offers, blockNumber, price = null } = parameters;
+	const { chainId, offers, blockNumber, price = null } = parameters;
 	const rowsByKey = /* @__PURE__ */ new Map();
 	for (const offer of offers) for (const collateral of offer.collaterals) {
-		const key = `${offer.chainId}-${collateral.oracle}`.toLowerCase();
+		const key = `${chainId}-${collateral.oracle}`.toLowerCase();
 		if (rowsByKey.has(key)) continue;
 		rowsByKey.set(key, fromCollateral({
-			chainId: offer.chainId,
+			chainId,
 			collateral,
 			blockNumber,
 			price
@@ -2777,11 +2889,14 @@ let Conversion;
 //#region src/core/Position.ts
 var Position_exports = /* @__PURE__ */ __exportAll({
 	Type: () => Type,
-	from: () => from$12
+	from: () => from$12,
+	positionTypeId: () => positionTypeId
 });
 let Type = /* @__PURE__ */ function(Type) {
 	Type["ERC20"] = "erc20";
 	Type["VAULT_V1"] = "vault_v1";
+	Type["DEBT_OF"] = "debtOf";
+	Type["COLLATERAL_OF"] = "collateralOf";
 	return Type;
 }({});
 /**
@@ -2797,10 +2912,16 @@ function from$12(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
@@ -2939,7 +3060,7 @@ function fromSnakeCase(snake) {
 */
 function random() {
 	return from$11({
-		obligationId: id(random$2()),
+		obligationId: hex(32),
 		ask: { tick: int(TICK_RANGE + 1) },
 		bid: { tick: int(TICK_RANGE + 1) }
 	});
@@ -3129,6 +3250,8 @@ function from$9(parameters) {
 		from: parameters.from.toLowerCase(),
 		to: parameters.to.toLowerCase(),
 		value: parameters.value,
+		type: parameters.type,
+		asset: parameters.asset.toLowerCase(),
 		blockNumber: parameters.blockNumber
 	};
 }
@@ -3310,7 +3433,7 @@ const verifySignatureAndRecoverAddress = async (params) => {
 const encode = async (tree, signature, domain) => {
 	const errorFactory = (reason) => new EncodeError(reason);
 	const normalizedDomain = normalizeSignatureDomain(domain, errorFactory);
-	validateTreeForEncoding(tree, normalizedDomain);
+	validateTreeForEncoding(tree);
 	await verifySignatureAndRecoverAddress({
 		root: tree.root,
 		signature,
@@ -3342,14 +3465,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$8(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);
@@ -3416,8 +3535,6 @@ const decode = async (encoded, domain) => {
 	}
 	const tree = from$8(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,
@@ -3470,7 +3587,7 @@ const BrandTypeId = Symbol.for("mempool/Brand");
 
 //#endregion
 //#region src/database/drizzle/VERSION.ts
-const VERSION = "router_v1.8";
+const VERSION = "router_v1.11";
 
 //#endregion
 //#region src/database/drizzle/schema.ts
@@ -3480,13 +3597,15 @@ var schema_exports = /* @__PURE__ */ __exportAll({
 	TABLE_NAMES: () => TABLE_NAMES,
 	VERSIONED_TABLE_NAMES: () => VERSIONED_TABLE_NAMES,
 	callbacks: () => callbacks,
-	chains: () => chains$1,
+	chains: () => chains,
 	collectors: () => collectors,
 	consumedEvents: () => consumedEvents,
 	groups: () => groups,
 	lots: () => lots,
+	lotsPositions: () => lotsPositions,
 	merklePaths: () => merklePaths,
 	obligationCollateralsV2: () => obligationCollateralsV2,
+	obligationIdKeys: () => obligationIdKeys,
 	obligations: () => obligations,
 	offers: () => offers,
 	offersCallbacks: () => offersCallbacks,
@@ -3502,6 +3621,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";
@@ -3515,6 +3635,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";
@@ -3523,11 +3644,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(),
@@ -3575,24 +3701,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$1.chainId, oracles$1.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$1 = s.table(EnumTableName.ORACLES, {
 	chainId: bigint("chain_id", { mode: "number" }).$type().notNull(),
@@ -3608,8 +3729,8 @@ const oracles$1 = 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
@@ -3637,6 +3758,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,
@@ -3655,10 +3780,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, {
@@ -3666,23 +3800,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(),
@@ -3715,11 +3851,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: [
@@ -3761,11 +3897,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", {
@@ -3774,34 +3910,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) => [
@@ -3809,12 +3949,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"),
@@ -3822,16 +3966,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", {
@@ -3839,12 +3988,20 @@ 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$1.chainId, { onDelete: "no action" }),
+	chainId: bigint("chain_id", { mode: "number" }).$type().notNull().references(() => chains.chainId, { onDelete: "no action" }),
 	name: text("name").$type().notNull(),
 	blockNumber: bigint("block_number", { mode: "number" }).notNull(),
 	epoch: numeric("epoch", {
@@ -3853,7 +4010,7 @@ const collectors = s.table(EnumTableName.COLLECTORS, {
 	}).default("0").notNull(),
 	updatedAt: timestamp("updated_at").defaultNow().notNull()
 }, (table) => [uniqueIndex("collectors_chain_name_idx").on(table.chainId, table.name)]);
-const chains$1 = s.table(EnumTableName.CHAINS, {
+const chains = s.table(EnumTableName.CHAINS, {
 	chainId: bigint("chain_id", { mode: "number" }).$type().notNull(),
 	blockNumber: bigint("block_number", { mode: "number" }).notNull(),
 	epoch: numeric("epoch", {
@@ -3868,18 +4025,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$9({
+				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$9({
+				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$9({
+				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$9({
+				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$9({
+				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$9({
+				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;
@@ -3898,179 +4389,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);
+			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);
 			}
-			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 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({
@@ -4086,15 +4461,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({
@@ -4105,7 +4492,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,
@@ -4120,10 +4507,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$9({
+			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$12({
+		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();
@@ -4137,9 +4724,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({
@@ -4202,10 +4790,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) {
@@ -4224,14 +4816,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$1 = obligationId(offer, {
+						chainId: client.chain.id,
+						morphoV2
+					}).toLowerCase();
+					offersWithBlock.push({
+						offer,
+						blockNumber: treeBlockNumber,
+						obligationId: obligationId$1
+					});
+					obligationIdsByOfferHash.set(offerHash, obligationId$1);
+				}
+				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({
@@ -4241,19 +4854,23 @@ async function* collectOffersV2(parameters) {
 				});
 				throw new Error("Gatekeeper validation failed", { cause: error });
 			}
-			const dependencies = buildOfferDependencies(offersWithBlock);
+			const dependencies = buildOfferDependencies({
+				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);
@@ -4316,7 +4933,7 @@ async function* collectOffersV2(parameters) {
 	}
 }
 function decodeCallbacks(parameters) {
-	const { offers } = parameters;
+	const { offers, chainId } = parameters;
 	if (offers.length === 0) return {
 		callbacks: [],
 		positions: [],
@@ -4325,12 +4942,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$12({
-			chainId: offer.chainId,
+			chainId,
 			contract: loanToken,
 			user: offer.maker,
 			type: Type.ERC20,
@@ -4338,20 +4955,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
 			}]
 		});
 	}
@@ -4361,34 +4981,42 @@ function decodeCallbacks(parameters) {
 		lots
 	};
 }
-function buildOfferDependencies(offers) {
+function buildOfferDependencies(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$1 = obligationId(offer);
-		if (!obligationsById.get(obligationId$1)) obligationsById.set(obligationId$1, from$15({
-			chainId: offer.chainId,
-			loanToken: offer.loanToken,
-			maturity: offer.maturity,
-			collaterals: offer.collaterals
-		}));
+		if (!obligationsById.get(obligationId)) obligationsById.set(obligationId, {
+			obligationId,
+			chainId,
+			morphoV2,
+			obligation: from$15({
+				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$13({
-				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
@@ -4405,15 +5033,22 @@ function buildOfferDependencies(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$3 = hash(entry.offer).toLowerCase();
-		if (!inserted.has(hash$3)) continue;
-		if (seen.has(hash$3)) continue;
-		seen.add(hash$3);
+		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;
@@ -4528,7 +5163,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,
@@ -4683,12 +5318,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 {
@@ -4811,7 +5449,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",
@@ -5038,10 +5677,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
@@ -5090,7 +5729,7 @@ const from$7 = (parameters) => {
 	});
 	return {
 		offersCollector: collectorBuilder.buildOffersCollector({ options: { maxBatchSize } }),
-		consumedEventsCollector: collectorBuilder.buildConsumedEventsCollector({ options: { maxBatchSize } }),
+		morphoV2Collector: collectorBuilder.buildMorphoV2Collector({ options: { maxBatchSize } }),
 		pricesCollector: collectorBuilder.buildPricesCollector({ options: {
 			maxBatchSize,
 			retryAttempts,
@@ -5112,7 +5751,7 @@ var Indexer_exports = /* @__PURE__ */ __exportAll({
 });
 function from$6(config) {
 	const { client, gatekeeper, db, interval = 1e4, maxBatchSize = 1e3, maxBlockNumber, blockWindow, retryAttempts, retryDelayMs } = config;
-	const { offersCollector, consumedEventsCollector, positionsCollector, pricesCollector } = from$7({
+	const { offersCollector, morphoV2Collector, positionsCollector, pricesCollector } = from$7({
 		client,
 		db,
 		gatekeeper,
@@ -5127,7 +5766,7 @@ function from$6(config) {
 		client,
 		collectors: [
 			offersCollector,
-			consumedEventsCollector,
+			morphoV2Collector,
 			positionsCollector,
 			pricesCollector
 		]
@@ -5332,12 +5971,13 @@ var ObligationResponse_exports = /* @__PURE__ */ __exportAll({ from: () => from$
 * @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$4(obligation, quote) {
+function from$4(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,
@@ -5404,12 +6044,7 @@ function from$3(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(),
@@ -6036,10 +6671,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
@@ -6057,6 +6688,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.",
@@ -6823,6 +7459,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$1.preprocess((value) => {
 	if (value === void 0) return void 0;
 	if (Array.isArray(value)) {
@@ -6886,7 +7528,7 @@ const GetConfigContractsQueryParams = z$1.object({
 });
 const GetOffersQueryParams = PaginationQueryParams.omit({ cursor: true }).extend({
 	cursor: z$1.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$1.enum(["buy", "sell"]).optional().meta({
@@ -6913,10 +7555,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;
 	}
@@ -7026,7 +7668,13 @@ const GetBookParams = z$1.object({
 		example: "buy"
 	})
 });
-const ValidateOffersBody = z$1.object({ offers: z$1.array(z$1.unknown()).min(1, { message: "'offers' must contain at least 1 offer" }) }).strict();
+const ValidateOffersBody = z$1.object({
+	chain_id: z$1.number().int().positive("chain_id must be a positive integer").meta({
+		description: "Chain id used for chain-scoped validation rules.",
+		example: 1
+	}),
+	offers: z$1.array(z$1.unknown()).min(1, { message: "'offers' must contain at least 1 offer" })
+}).strict();
 const GetUserPositionsParams = z$1.object({
 	...PaginationQueryParams.shape,
 	user_address: z$1.string().regex(/^0x[a-fA-F0-9]{40}$/, { error: "User address must be a valid 20-byte address" }).transform((val) => val.toLowerCase()).meta({
@@ -7165,19 +7813,19 @@ async function getConfigContracts(query, chainRegistry) {
 	});
 	let cursorContract = null;
 	if (cursor) try {
-		cursorContract = parseCursor$1(cursor);
+		cursorContract = parseCursor$3(cursor);
 	} catch (err) {
 		return failure(err);
 	}
 	const startIndex = cursorContract ? findStartIndex$1(contracts, cursorContract) : 0;
 	const page = contracts.slice(startIndex, startIndex + limit);
-	const nextCursor = startIndex + limit < contracts.length && page.length > 0 ? formatCursor$1(page.at(-1)) : null;
+	const nextCursor = startIndex + limit < contracts.length && page.length > 0 ? formatCursor$3(page.at(-1)) : null;
 	return success({
 		data: page,
 		cursor: nextCursor
 	});
 }
-function parseCursor$1(cursor) {
+function parseCursor$3(cursor) {
 	const [chain, address] = cursor.split(":", 2);
 	if (!chain || !address) throw new BadRequestError$1("Cursor must be in the format chain_id:0x...");
 	return {
@@ -7185,7 +7833,7 @@ function parseCursor$1(cursor) {
 		address: address.toLowerCase()
 	};
 }
-function formatCursor$1(contract) {
+function formatCursor$3(contract) {
 	return `${contract.chain_id}:${contract.address.toLowerCase()}`;
 }
 function findStartIndex$1(contracts, cursor) {
@@ -7428,7 +8076,7 @@ async function getConfigRules(query, chains) {
 	const checksum = buildConfigRulesChecksum(filteredRules);
 	let cursorRule = null;
 	if (cursor) try {
-		cursorRule = parseCursor(cursor);
+		cursorRule = parseCursor$2(cursor);
 	} catch (err) {
 		return failure(err);
 	}
@@ -7436,7 +8084,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(filteredRules, cursorRule) : 0;
 	const page = filteredRules.slice(startIndex, startIndex + limit);
-	const nextCursor = startIndex + limit < filteredRules.length && page.length > 0 ? formatCursor(page.at(-1)) : null;
+	const nextCursor = startIndex + limit < filteredRules.length && page.length > 0 ? formatCursor$2(page.at(-1)) : null;
 	const response = success({
 		data: page,
 		cursor: nextCursor
@@ -7444,14 +8092,14 @@ async function getConfigRules(query, chains) {
 	response.body.meta.checksum = checksum;
 	return response;
 }
-function formatCursor(rule) {
+function formatCursor$2(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(cursor) {
+function parseCursor$2(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");
@@ -7744,23 +8392,22 @@ function create$16(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$3), gte(offers.maturity, now$3), lte(offers.start, now$3), 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$3), gte(offers.maturity, now$3), lte(offers.start, now$3), 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$3), gte(offers.maturity, now$3), lte(offers.start, now$3), 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$3), gte(offers.maturity, now$3), lte(offers.start, now$3), 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$1.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$1, sql`${obligationCollateralsV2.oracleChainId} = ${oracles$1.chainId}
-         AND ${obligationCollateralsV2.oracleAddress} = ${oracles$1.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$3), 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$3), collateralFilter)).as("obligations_with_quotes");
 		const sortColumns = {
 			id: obligationsWithQuotes.obligationId,
 			ask: obligationsWithQuotes.ask,
@@ -7780,22 +8427,25 @@ function create$16(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) => {
-			return {
-				obligation: from$15({
-					chainId: row.chainId,
-					loanToken: row.loanToken,
-					collaterals: row.collaterals.sort((left, right) => left.asset.localeCompare(right.asset)).map((collateral) => from$17({
-						asset: collateral.asset,
-						oracle: collateral.oracle,
-						lltv: from$18(BigInt(collateral.lltv))
-					})),
-					maturity: row.maturity
-				}),
-				quote: from$11({
-					obligationId: row.obligationId,
-					ask: { tick: row.askTick },
-					bid: { tick: row.bidTick }
-				}),
+			const obligation = from$15({
+				loanToken: row.loanToken,
+				collaterals: row.collaterals.sort((left, right) => left.asset.localeCompare(right.asset)).map((collateral) => from$17({
+					asset: collateral.asset,
+					oracle: collateral.oracle,
+					lltv: from$18(BigInt(collateral.lltv))
+				})),
+				maturity: row.maturity
+			});
+			const quote = from$11({
+				obligationId: row.obligationId,
+				ask: { tick: row.askTick },
+				bid: { tick: row.bidTick }
+			});
+			return {
+				obligationId: row.obligationId,
+				chainId: row.chainId,
+				obligation,
+				quote,
 				cursorValues: {
 					id: row.obligationId,
 					ask: toBigInt(row.ask),
@@ -7813,6 +8463,8 @@ function create$16(parameters) {
 		}) : null;
 		return {
 			obligations: listedRows.map((row) => ({
+				obligationId: row.obligationId,
+				chainId: row.chainId,
 				obligation: row.obligation,
 				quote: row.quote
 			})),
@@ -7950,7 +8602,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$4(obligation.obligation, obligation.quote),
+			data: from$4(obligation.obligation, obligation.quote, obligation.chainId),
 			cursor: null
 		});
 	} catch (err) {
@@ -7991,7 +8643,7 @@ async function getObligations$1(queryParameters, db) {
 			limit: query.limit
 		});
 		return success({
-			data: listing.obligations.map((item) => from$4(item.obligation, item.quote)),
+			data: listing.obligations.map((item) => from$4(item.obligation, item.quote, item.chainId)),
 			cursor: listing.nextCursor
 		});
 	} catch (err) {
@@ -8029,10 +8681,10 @@ function create$15(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,
@@ -8042,48 +8694,67 @@ function create$15(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$1)) {
-							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$1)) {
 						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$1(rawCursor) : void 0;
 			const collateralsLateral = db.select({ collaterals: sql`COALESCE(
         jsonb_agg(
           jsonb_build_object(
             'asset', ${obligationCollateralsV2.asset},
-            'oracle', ${oracles$1.address},
+            'oracle', ${obligationCollateralsV2.oracleAddress},
             'lltv', ${obligationCollateralsV2.lltv}
           )
         ),
         '[]'::jsonb
-      )`.as("collaterals") }).from(obligationCollateralsV2).innerJoin(oracles$1, sql`${obligationCollateralsV2.oracleChainId} = ${oracles$1.chainId}
-             AND ${obligationCollateralsV2.oracleAddress} = ${oracles$1.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,
@@ -8095,17 +8766,18 @@ function create$15(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),
@@ -8137,7 +8809,10 @@ function create$15(config) {
 			});
 			return {
 				rows,
-				nextCursor: rows.length === limit ? rows[rows.length - 1].hash : null
+				nextCursor: rows.length === limit ? formatCursor$1({
+					hash: rows[rows.length - 1].hash,
+					obligationId: rows[rows.length - 1].obligationId
+				}) : null
 			};
 		},
 		delete: async (parameters) => {
@@ -8160,7 +8835,7 @@ function create$15(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, {
@@ -8190,6 +8865,134 @@ function create$15(config) {
 		}
 	};
 }
+const HEX_32$2 = /^0x[a-fA-F0-9]{64}$/;
+function parseCursor$1(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$1(input) {
+	return `${input.hash.toLowerCase()}:${input.obligationId.toLowerCase()}`;
+}
+
+//#endregion
+//#region src/database/domains/Trees.ts
+/**
+* Creates a Trees domain instance for managing merkle tree metadata.
+*
+* @param config - Configuration with database instance
+* @returns TreesDomain instance
+*/
+function create$14(config) {
+	const db = config.db;
+	return {
+		upsert: async (trees$1) => {
+			if (trees$1.length === 0) return [];
+			try {
+				return await db.transaction(async (dbTx) => {
+					const roots = [];
+					for (const { root, signature } of trees$1) {
+						const normalizedRoot = root.toLowerCase();
+						const normalizedSignature = signature.toLowerCase();
+						roots.push(normalizedRoot);
+						await dbTx.insert(trees).values({
+							root: normalizedRoot,
+							rootSignature: normalizedSignature
+						}).onConflictDoUpdate({
+							target: [trees.root],
+							set: {
+								rootSignature: normalizedSignature,
+								createdAt: sql`NOW()`
+							}
+						});
+					}
+					return roots;
+				});
+			} catch (err) {
+				const error = err instanceof Error ? err : new Error(String(err));
+				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$1)) 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 (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(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) {
+				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;
+		}
+	};
+}
+/**
+* Concatenates an array of 32-byte hex hashes into a single hex string.
+* Empty arrays return "0x".
+*/
+function concatenateProofs(proofs) {
+	if (proofs.length === 0) return "0x";
+	return `0x${proofs.map((proof) => proof.toLowerCase().slice(2)).join("")}`;
+}
+/**
+* Splits a concatenated hex string back into an array of 32-byte hex hashes.
+* Returns empty array for "0x" or empty string.
+*/
+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).toLowerCase()}`);
+	return proofs;
+}
+function toAttestationKey(offer) {
+	return `${offer.offerHash.toLowerCase()}:${offer.obligationId.toLowerCase()}`;
+}
 
 //#endregion
 //#region src/api/Controllers/getOffers.ts
@@ -8201,23 +9004,20 @@ function create$15(config) {
 */
 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$1.address},
+            'oracle', ${obligationCollateralsV2.oracleAddress},
             'lltv', ${obligationCollateralsV2.lltv}
           )
         ),
         '[]'::jsonb
-      )`.as("collaterals") }).from(obligationCollateralsV2).innerJoin(oracles$1, sql`${obligationCollateralsV2.oracleChainId} = ${oracles$1.chainId}
-             AND ${obligationCollateralsV2.oracleAddress} = ${oracles$1.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((
@@ -8262,6 +9062,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}),
@@ -8271,6 +9072,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,
@@ -8283,7 +9085,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,
@@ -8300,7 +9102,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(
@@ -8308,10 +9110,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),
@@ -8343,7 +9146,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$1(queryParameters, db) {
@@ -8362,12 +9165,18 @@ async function getOffers$1(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$2 = hash(row);
-				const attestation = attestationMap.get(hash$2);
+				const key = toAttestationKey({
+					offerHash: row.hash,
+					obligationId: row.obligationId
+				});
+				const attestation = attestationMap.get(key);
 				return from$3({
 					...row,
 					...attestation
@@ -8385,6 +9194,19 @@ async function getOffers$1(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$1.test(rawHash) || !HEX_32$1.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$1 = /^0x[a-fA-F0-9]{64}$/;
 
 //#endregion
 //#region src/api/Controllers/getUserPositions.ts
@@ -8426,7 +9248,8 @@ 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++) {
@@ -8445,7 +9268,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));
@@ -8506,14 +9332,14 @@ var Controllers_exports = /* @__PURE__ */ __exportAll({
 //#region src/api/Api.ts
 function from$1(config) {
 	const { db, gatekeeper, port, chainRegistry } = config;
-	return create$14({
+	return create$13({
 		port,
 		db,
 		gatekeeper,
 		chainRegistry
 	});
 }
-function create$14(params) {
+function create$13(params) {
 	return { serve: () => serve$1(params) };
 }
 /**
@@ -8640,7 +9466,7 @@ var RouterApi_exports = /* @__PURE__ */ __exportAll({
 	RouterStatusResponse: () => RouterStatusResponse,
 	UsersController: () => UsersController,
 	ValidateController: () => ValidateController,
-	create: () => create$14,
+	create: () => create$13,
 	from: () => from$1,
 	parse: () => parse,
 	safeParse: () => safeParse
@@ -8723,7 +9549,6 @@ async function getOffers(apiClient, parameters) {
 				group: offerData.group,
 				session: offerData.session,
 				buy: offerData.buy,
-				chain_id: item.chain_id,
 				loan_token: offerData.obligation.loan_token,
 				collaterals: offerData.obligation.collaterals.map((collateral) => ({
 					asset: collateral.token,
@@ -8771,7 +9596,6 @@ async function getObligations(apiClient, parameters) {
 	}
 	const obligations = data?.data.map((item) => {
 		const obligation = fromSnakeCase$2({
-			chain_id: item.chain_id,
 			loan_token: item.loan_token,
 			collaterals: item.collaterals.map((collateral) => ({
 				asset: collateral.token,
@@ -8780,16 +9604,17 @@ async function getObligations(apiClient, parameters) {
 			})),
 			maturity: from$16(item.maturity)
 		});
-		const { obligationId: _, ...returned } = {
-			id: () => id(obligation),
+		const { obligationId: _, ...quote } = from$11({
+			obligationId: item.id,
+			ask: { tick: item.ask.tick },
+			bid: { tick: item.bid.tick }
+		});
+		return {
+			id: item.id,
+			chainId: item.chain_id,
 			...obligation,
-			...from$11({
-				obligationId: item.id,
-				ask: { tick: item.ask.tick },
-				bid: { tick: item.bid.tick }
-			})
+			...quote
 		};
-		return returned;
 	}) ?? [];
 	return {
 		cursor: data?.cursor ?? null,
@@ -8836,13 +9661,15 @@ var drizzle_exports = /* @__PURE__ */ __exportAll({
 	VERSION: () => VERSION,
 	VERSIONED_TABLE_NAMES: () => VERSIONED_TABLE_NAMES,
 	callbacks: () => callbacks,
-	chains: () => chains$1,
+	chains: () => chains,
 	collectors: () => collectors,
 	consumedEvents: () => consumedEvents,
 	groups: () => groups,
 	lots: () => lots,
+	lotsPositions: () => lotsPositions,
 	merklePaths: () => merklePaths,
 	obligationCollateralsV2: () => obligationCollateralsV2,
+	obligationIdKeys: () => obligationIdKeys,
 	obligations: () => obligations,
 	offers: () => offers,
 	offersCallbacks: () => offersCallbacks,
@@ -8859,14 +9686,14 @@ var drizzle_exports = /* @__PURE__ */ __exportAll({
 //#endregion
 //#region src/database/domains/Blocks.ts
 /** Postgres implementation. */
-const create$13 = (config) => {
+const create$12 = (config) => {
 	const { db, chainRegistry } = config;
 	const getChain = async (chainId) => {
 		const rows = await db.select({
-			chainId: chains$1.chainId,
-			blockNumber: chains$1.blockNumber,
-			epoch: chains$1.epoch
-		}).from(chains$1).where(eq(chains$1.chainId, chainId)).limit(1);
+			chainId: chains.chainId,
+			blockNumber: chains.blockNumber,
+			epoch: chains.epoch
+		}).from(chains).where(eq(chains.chainId, chainId)).limit(1);
 		if (rows.length === 0) throw new Error(`Chain state not initialized for chain ${chainId}. Call blocks.init first.`);
 		const row = rows[0];
 		return {
@@ -8894,11 +9721,11 @@ const create$13 = (config) => {
 	};
 	const getChains = async (parameters) => {
 		return (await db.select({
-			chainId: chains$1.chainId,
-			blockNumber: chains$1.blockNumber,
-			epoch: chains$1.epoch,
-			updatedAt: chains$1.updatedAt
-		}).from(chains$1).where(parameters?.chainId !== void 0 ? eq(chains$1.chainId, parameters.chainId) : sql`TRUE`).orderBy(asc(chains$1.chainId))).map((row) => ({
+			chainId: chains.chainId,
+			blockNumber: chains.blockNumber,
+			epoch: chains.epoch,
+			updatedAt: chains.updatedAt
+		}).from(chains).where(parameters?.chainId !== void 0 ? eq(chains.chainId, parameters.chainId) : sql`TRUE`).orderBy(asc(chains.chainId))).map((row) => ({
 			chainId: row.chainId,
 			blockNumber: Number(row.blockNumber),
 			epoch: BigInt(row.epoch),
@@ -8924,14 +9751,14 @@ const create$13 = (config) => {
 		const name = parameters.collectorName.toLowerCase();
 		const deploymentBlock = chainRegistry.getById(parameters.chainId)?.custom?.mempool.blockCreated ?? 0;
 		const { chain, collector } = await db.transaction(async (dbTx) => {
-			const chainRows = await dbTx.insert(chains$1).values({
+			const chainRows = await dbTx.insert(chains).values({
 				chainId: parameters.chainId,
 				blockNumber: deploymentBlock
 			}).onConflictDoUpdate({
-				target: chains$1.chainId,
+				target: chains.chainId,
 				set: {
-					blockNumber: sql`${chains$1.blockNumber}`,
-					epoch: sql`${chains$1.epoch}`
+					blockNumber: sql`${chains.blockNumber}`,
+					epoch: sql`${chains.epoch}`
 				}
 			}).returning();
 			if (chainRows.length === 0) throw new Error(`Failed to initialize chain state for chain ${parameters.chainId}`);
@@ -8971,28 +9798,28 @@ const create$13 = (config) => {
 	const advanceChain = async (parameters) => {
 		if (parameters.blockNumber < 0) throw new Error("Block number cannot be negative");
 		if (parameters.epoch < 0n) throw new Error("Epoch cannot be negative");
-		if ((await db.update(chains$1).set({
+		if ((await db.update(chains).set({
 			blockNumber: parameters.blockNumber,
 			epoch: parameters.epoch.toString(),
 			updatedAt: sql`now()`
-		}).where(eq(chains$1.chainId, parameters.chainId)).returning()).length === 0) throw new Error(`Chain state not initialized for chain ${parameters.chainId}. Call blocks.init first.`);
+		}).where(eq(chains.chainId, parameters.chainId)).returning()).length === 0) throw new Error(`Chain state not initialized for chain ${parameters.chainId}. Call blocks.init first.`);
 	};
 	const advanceCollector = async (parameters) => {
 		if (parameters.blockNumber < 0) throw new Error("Block number cannot be negative");
 		if (parameters.epoch < 0n) throw new Error("Epoch cannot be negative");
 		const name = parameters.collectorName.toLowerCase();
 		const chain = db.select({
-			chainId: chains$1.chainId,
-			currentEpoch: chains$1.epoch,
-			currentBlockNumber: chains$1.blockNumber
-		}).from(chains$1).where(eq(chains$1.chainId, parameters.chainId)).as("chain");
+			chainId: chains.chainId,
+			currentEpoch: chains.epoch,
+			currentBlockNumber: chains.blockNumber
+		}).from(chains).where(eq(chains.chainId, parameters.chainId)).as("chain");
 		const hasReorgHappened = (await db.select().from(collectors).leftJoin(chain, eq(collectors.chainId, chain.chainId)).where(and(eq(collectors.chainId, parameters.chainId), eq(collectors.name, name), gt(chain.currentEpoch, collectors.epoch), eq(chain.currentEpoch, parameters.epoch.toString()), gte(collectors.blockNumber, parameters.blockNumber))).limit(1)).length > 0;
 		if ((await db.update(collectors).set({
 			blockNumber: parameters.blockNumber,
 			epoch: parameters.epoch.toString(),
 			updatedAt: sql`now()`
 		}).from(chain).where(and(eq(collectors.chainId, parameters.chainId), eq(collectors.name, name), eq(chain.currentEpoch, parameters.epoch.toString()), gte(chain.currentBlockNumber, parameters.blockNumber), ...hasReorgHappened ? [] : [lte(collectors.blockNumber, parameters.blockNumber)])).returning()).length > 0) return;
-		if ((await db.select({ chainId: chains$1.chainId }).from(chains$1).where(eq(chains$1.chainId, parameters.chainId)).limit(1)).length === 0) throw new Error(`Chain state not initialized for chain ${parameters.chainId}. Call blocks.init first.`);
+		if ((await db.select({ chainId: chains.chainId }).from(chains).where(eq(chains.chainId, parameters.chainId)).limit(1)).length === 0) throw new Error(`Chain state not initialized for chain ${parameters.chainId}. Call blocks.init first.`);
 		if ((await db.select({ chainId: collectors.chainId }).from(collectors).where(and(eq(collectors.chainId, parameters.chainId), eq(collectors.name, name))).limit(1)).length === 0) throw new Error(`Collector state not initialized for ${name} on chain ${parameters.chainId}. Call blocks.init first.`);
 		throw new Error(`A chain reorg has happened on chain ${parameters.chainId}, update of the collector ${name} is aborted`);
 	};
@@ -9040,7 +9867,7 @@ const create$13 = (config) => {
 //#region src/database/domains/Book.ts
 const DEFAULT_LIMIT$2 = 100;
 const MAX_TOTAL_OFFERS = 500;
-function create$12(config) {
+function create$11(config) {
 	const db = config.db;
 	const logger = getLogger();
 	const getOffers = async (parameters) => {
@@ -9126,18 +9953,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$1} 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")
@@ -9145,6 +9971,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}
@@ -9171,8 +9998,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.*
@@ -9271,7 +10100,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
@@ -9356,11 +10187,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,
@@ -9409,6 +10242,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),
@@ -9508,7 +10342,7 @@ let LevelCursor;
 * @param db - Database core instance.
 * @returns Callbacks domain. {@link CallbacksDomain}
 */
-function create$11(db) {
+function create$10(db) {
 	return {
 		upsert: async (inputs) => {
 			if (inputs.length === 0) return;
@@ -9522,18 +10356,21 @@ function create$11(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;
@@ -9543,6 +10380,7 @@ function create$11(db) {
 						positionChainId: normalized.chainId,
 						positionContract: normalized.contract,
 						positionUser: normalized.user,
+						positionTypeId: normalized.positionTypeId,
 						amount: normalized.amount.toString()
 					});
 				}
@@ -9563,7 +10401,7 @@ function create$11(db) {
 
 //#endregion
 //#region src/database/domains/Consumed.ts
-function create$10(db) {
+function create$9(db) {
 	return {
 		create: async (events) => {
 			if (events.length === 0) return;
@@ -9611,7 +10449,7 @@ function create$10(db) {
 * @param db - Database core instance.
 * @returns Groups domain. {@link GroupsDomain}
 */
-function create$9(db) {
+function create$8(db) {
 	return { create: async (groups$1) => {
 		if (groups$1.length === 0) return;
 		const rows = groups$1.map((group) => ({
@@ -9627,7 +10465,7 @@ function create$9(db) {
 
 //#endregion
 //#region src/database/domains/Lots.ts
-function create$8(db) {
+function create$7(db) {
 	return {
 		get: async (parameters) => {
 			const { chainId, user, contract, group, obligationId } = parameters ?? {};
@@ -9655,6 +10493,17 @@ function create$8(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");
@@ -9680,58 +10529,72 @@ function create$8(db) {
 * @param db - Database core instance.
 * @returns Obligations domain. {@link ObligationsDomain}
 */
-function create$7(db) {
+function create$6(db) {
 	return {
 		get: async (parameters) => {
 			const chainIds = parameters?.chainId;
 			const now$1 = 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$1.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$1, sql`${obligationCollateralsV2.oracleChainId} = ${oracles$1.chainId}
-             AND ${obligationCollateralsV2.oracleAddress} = ${oracles$1.address}`).groupBy(obligations.obligationId).where(and(chainIds !== void 0 && chainIds.length > 0 ? inArray(obligations.chainId, chainIds) : void 0, gte(obligations.maturity, now$1))).orderBy(asc(obligations.obligationId))).map((row) => from$15({
+			}).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$1))).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$17({
-					asset: collateral.asset,
-					oracle: collateral.oracle,
-					lltv: from$18(BigInt(collateral.lltv))
-				})),
-				maturity: row.maturity
+				morphoV2: row.morphoV2,
+				obligation: from$15({
+					loanToken: row.loanToken,
+					collaterals: row.collaterals.sort((left, right) => left.asset.localeCompare(right.asset)).map((collateral) => from$17({
+						asset: collateral.asset,
+						oracle: collateral.oracle,
+						lltv: from$18(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$1)) 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$1)) 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$1)) 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 });
 			}
 		}
 	};
@@ -9739,7 +10602,7 @@ function create$7(db) {
 
 //#endregion
 //#region src/database/domains/Offsets.ts
-function create$6(db) {
+function create$5(db) {
 	return { get: async (parameters) => {
 		const { chainId, user, contract, group, obligationId } = parameters ?? {};
 		const conditions = [];
@@ -9761,7 +10624,7 @@ function create$6(db) {
 
 //#endregion
 //#region src/database/domains/Oracles.ts
-function create$5(db) {
+function create$4(db) {
 	return {
 		get: async ({ chainId }) => {
 			return (await db.select({
@@ -9804,19 +10667,20 @@ function create$5(db) {
 //#endregion
 //#region src/database/domains/Positions.ts
 const DEFAULT_LIMIT$1 = 100;
-const create$4 = (db) => {
+const create$3 = (db) => {
 	return {
 		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)) {
@@ -9827,14 +10691,14 @@ const create$4 = (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
 				};
 			});
@@ -9844,11 +10708,12 @@ const create$4 = (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()`
 					},
@@ -9867,20 +10732,23 @@ const create$4 = (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) => ({
@@ -9889,14 +10757,14 @@ const create$4 = (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$1, cursor: encodedCursor } = parameters;
+			const { user, type, limit = DEFAULT_LIMIT$1, cursor: encodedCursor } = parameters;
 			let cursor = null;
 			if (encodedCursor !== null && encodedCursor !== void 0) {
 				const parsed = JSON.parse(Buffer.from(encodedCursor, "base64url").toString("utf8"));
@@ -9904,6 +10772,8 @@ const create$4 = (db) => {
 				cursor = {
 					chainId: parsed.chainId,
 					contract: parsed.contract,
+					positionTypeId: parsed.positionTypeId ?? 0,
+					asset: parsed.asset ?? "",
 					obligationId: parsed.obligationId ?? null
 				};
 			}
@@ -9991,6 +10861,8 @@ const create$4 = (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
@@ -10000,14 +10872,18 @@ const create$4 = (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) => ({
@@ -10022,21 +10898,23 @@ const create$4 = (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;
 			});
@@ -10046,33 +10924,35 @@ const create$4 = (db) => {
 
 //#endregion
 //#region src/database/domains/Transfers.ts
-const create$3 = (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$1)) {
-			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$2 = (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$1)) {
+				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
@@ -10081,7 +10961,8 @@ const create$3 = (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 (
@@ -10090,6 +10971,7 @@ const create$3 = (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
@@ -10098,6 +10980,7 @@ const create$3 = (db) => ({ create: async (transfers$1) => {
               nt."contract",
               nt."to" AS "user",
               nt."value" AS delta,
+              nt.asset,
               nt.block_number
             FROM new_transfers nt
           ),
@@ -10107,12 +10990,15 @@ const create$3 = (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
           ),
@@ -10121,10 +11007,11 @@ const create$3 = (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
@@ -10136,101 +11023,109 @@ const create$3 = (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;
-	});
-} });
-
-//#endregion
-//#region src/database/domains/Trees.ts
-/**
-* Creates a Trees domain instance for managing merkle tree metadata.
-*
-* @param config - Configuration with database instance
-* @returns TreesDomain instance
-*/
-function create$2(config) {
-	const db = config.db;
-	return {
-		create: 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);
-						await dbTx.insert(trees).values({
-							root,
-							rootSignature: signature.toLowerCase()
-						}).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$1)) await dbTx.insert(merklePaths).values(batch).onConflictDoUpdate({
-							target: [merklePaths.offerHash],
-							set: {
-								treeRoot: sql`excluded.tree_root`,
-								proofNodes: sql`excluded.proof_nodes`,
-								createdAt: sql`NOW()`
-							}
-						});
-					}
-					return roots;
-				});
-			} 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 });
+				totalInserted += inserted.length;
 			}
-		},
-		getAttestations: async (hashes) => {
-			if (hashes.length === 0) return /* @__PURE__ */ new Map();
-			const normalizedHashes = hashes.map((h) => h.toLowerCase());
-			const results = await db.select({
-				offerHash: merklePaths.offerHash,
-				treeRoot: merklePaths.treeRoot,
-				proofNodes: merklePaths.proofNodes,
-				rootSignature: trees.rootSignature
-			}).from(merklePaths).innerJoin(trees, eq(merklePaths.treeRoot, trees.root)).where(inArray(merklePaths.offerHash, normalizedHashes));
-			const attestationMap = /* @__PURE__ */ new Map();
-			for (const row of results) attestationMap.set(row.offerHash, {
-				root: row.treeRoot,
-				signature: row.rootSignature,
-				proof: splitProofs(row.proofNodes)
-			});
-			return attestationMap;
-		}
-	};
-}
-/**
-* Concatenates an array of 32-byte hex hashes into a single hex string.
-* Empty arrays return "0x".
-*/
-function concatenateProofs(proofs) {
-	if (proofs.length === 0) return "0x";
-	return `0x${proofs.map((p) => p.slice(2)).join("")}`;
-}
-/**
-* Splits a concatenated hex string back into an array of 32-byte hex hashes.
-* Returns empty array for "0x" or empty string.
-*/
-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)}`);
-	return proofs;
-}
+			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/Validations.ts
@@ -10239,26 +11134,26 @@ function create$1(db) {
 	return {
 		get: async (params) => {
 			const { status: status$1, cursor, limit = DEFAULT_LIMIT } = 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(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$1 !== void 0) query = query.where(eq(status.code, status$1));
-			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$1 !== void 0) query = query.where(and(eq(status.code, status$1), 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(mapped[mapped.length - 1]) : null
 			};
 		},
 		upsert: async (results) => {
@@ -10268,6 +11163,7 @@ function create$1(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)));
@@ -10279,10 +11175,11 @@ function create$1(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$1)) await db.insert(validations).values(batch).onConflictDoUpdate({
-				target: [validations.offerHash],
+				target: [validations.offerHash, validations.obligationId],
 				set: {
 					statusId: sql`excluded.status_id`,
 					updatedAt: sql`NOW()`
@@ -10291,6 +11188,18 @@ function create$1(db) {
 		}
 	};
 }
+const HEX_32 = /^0x[a-fA-F0-9]{64}$/;
+function parseCursor(cursor) {
+	const [offerHash, obligationId] = cursor.split(":");
+	if (!offerHash || !obligationId || !HEX_32.test(offerHash) || !HEX_32.test(obligationId)) throw new Error("Invalid cursor format");
+	return {
+		offerHash: offerHash.toLowerCase(),
+		obligationId: obligationId.toLowerCase()
+	};
+}
+function formatCursor(input) {
+	return `${input.offerHash.toLowerCase()}:${input.obligationId.toLowerCase()}`;
+}
 
 //#endregion
 //#region src/database/Database.ts
@@ -10300,23 +11209,23 @@ var Database_exports = /* @__PURE__ */ __exportAll({
 });
 function createDomains(core, chainRegistry) {
 	return {
-		book: create$12({ db: core }),
-		blocks: create$13({
+		book: create$11({ db: core }),
+		blocks: create$12({
 			db: core,
 			chainRegistry
 		}),
-		callbacks: create$11(core),
+		callbacks: create$10(core),
 		offers: create$15({ db: core }),
-		consumed: create$10(core),
-		groups: create$9(core),
-		lots: create$8(core),
-		obligations: create$7(core),
-		offsets: create$6(core),
-		oracles: create$5(core),
-		trees: create$2({ db: core }),
+		consumed: create$9(core),
+		groups: create$8(core),
+		lots: create$7(core),
+		obligations: create$6(core),
+		offsets: create$5(core),
+		oracles: create$4(core),
+		trees: create$14({ db: core }),
 		validations: create$1(core),
-		positions: create$4(core),
-		transfers: create$3(core)
+		positions: create$3(core),
+		transfers: create$2(core)
 	};
 }
 function createReaders(core) {
@@ -10481,7 +11390,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
@@ -10635,19 +11544,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;
@@ -10694,7 +11607,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
@@ -10702,33 +11615,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;
@@ -10746,16 +11665,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;
     $$;
@@ -10778,11 +11702,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;
@@ -10851,8 +11790,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}`}`);
@@ -10994,11 +11937,12 @@ var Gatekeeper_exports = /* @__PURE__ */ __exportAll({ create: () => create });
 * @returns Gatekeeper instance. {@link Gatekeeper}
 */
 function create(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)
 		});
 	} };
 }
@@ -11008,28 +11952,11 @@ function create(parameters) {
 var Rules_exports = /* @__PURE__ */ __exportAll({
 	amountMutualExclusivity: () => amountMutualExclusivity,
 	callback: () => callback,
-	chains: () => chains,
 	collateralToken: () => collateralToken,
 	loanToken: () => loanToken,
 	maturity: () => maturity,
 	oracle: () => oracle,
-	sameMaker: () => sameMaker,
-	validity: () => validity
-});
-/**
-* set of rules to validate offers.
-*
-* @param _parameters - Validity parameters with chain and client
-* @returns Array of validation rules to evaluate against offers
-*/
-function validity(_parameters) {
-	return [single("expiry", "Validates that offer has not expired", (offer) => {
-		if (offer.expiry < Math.floor(Date.now() / 1e3)) return { message: "Expiry mismatch" };
-	})];
-}
-const chains = ({ 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(", ")})` };
+	sameMaker: () => sameMaker
 });
 const maturity = ({ maturities }) => single("maturity", `Validates that offer maturity is one of: [${maturities.join(", ")}]`, (offer) => {
 	const allowedMaturities = maturities.map((m) => from$16(m));
@@ -11045,9 +11972,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" };
 });
 /**
@@ -11055,9 +11982,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" };
 });
@@ -11066,9 +11993,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" };
 });
 /**
@@ -11100,11 +12027,12 @@ const amountMutualExclusivity = () => single("amount_mutual_exclusivity", "Valid
 
 //#endregion
 //#region src/gatekeeper/morphoRules.ts
-const morphoRules = (chains$3) => {
+const morphoRules = (parameters) => {
+	const { chains, chainId } = parameters;
 	const assetsByChainId = {};
 	const collateralAssetsByChainId = {};
 	const oraclesByChainId = {};
-	for (const chain of chains$3) {
+	for (const chain of chains) {
 		assetsByChainId[chain.id] = assets[chain.id.toString()] ?? [];
 		collateralAssetsByChainId[chain.id] = collateralAssets[chain.id.toString()] ?? [];
 		oraclesByChainId[chain.id] = oracles[chain.id.toString()] ?? [];
@@ -11112,15 +12040,23 @@ const morphoRules = (chains$3) => {
 	return [
 		sameMaker(),
 		amountMutualExclusivity(),
-		chains({ chains: chains$3 }),
 		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
+		})
 	];
 };
 
@@ -11150,9 +12086,7 @@ function from(parameters) {
 async function add(config, offers) {
 	if (!config.client.account) throw new WalletAccountNotSetError();
 	const tree = from$8(offers.map((o) => from$14(o)));
-	const chainId = await getChainId(config.client);
-	for (const offer of tree.offers) if (chainId !== offer.chainId) throw new ChainIdMismatchError(offer.chainId, chainId);
-	const signatureDomain$1 = resolveSignatureDomain(config, chainId);
+	const signatureDomain$1 = resolveSignatureDomain(config, await getChainId(config.client));
 	const signature = await config.client.signTypedData({
 		account: config.client.account,
 		domain: signatureDomain(signatureDomain$1),
@@ -11257,12 +12191,6 @@ var WalletAccountNotSetError = class extends BaseError {
 var ViemClientError = class extends BaseError {
 	name = "Mempool.ViemClientError";
 };
-var ChainIdMismatchError = class extends BaseError {
-	name = "Mempool.ChainIdMismatchError";
-	constructor(expected, actual) {
-		super(`Chain ID mismatch. Offer chain ID is ${expected}, network chain ID is ${actual}.`);
-	}
-};
 const resolveSignatureDomain = (config, chainId) => {
 	const chain = config.client.chain;
 	const verifyingContract = config.morphoAddress ?? chain?.custom?.morpho?.address ?? getChain(chainId)?.custom.morpho.address;
@@ -11291,7 +12219,6 @@ function connect(parameters) {
 //#endregion
 //#region src/mempool/index.ts
 var mempool_exports = /* @__PURE__ */ __exportAll({
-	ChainIdMismatchError: () => ChainIdMismatchError,
 	MissingMorphoAddressError: () => MissingMorphoAddressError,
 	ViemClientError: () => ViemClientError,
 	WalletAccountNotSetError: () => WalletAccountNotSetError,
@@ -11302,5 +12229,5 @@ var mempool_exports = /* @__PURE__ */ __exportAll({
 });
 
 //#endregion
-export { Abi_exports as Abi, BookResponse_exports as BookResponse, BooksController, BrandTypeId, Callback_exports as Callback, Chain_exports as Chain, ChainHealth, ChainRegistry_exports as ChainRegistry, ChainsHealthResponse, Collateral_exports as Collateral, CollectorHealth, CollectorsHealthResponse, ConfigContractsController, ConfigRulesController, Database_exports as Database, ERC4626_exports as ERC4626, Errors_exports as Errors, Format_exports as Format, Gatekeeper_exports as Gatekeeper, Client_exports as GatekeeperClient, Health_exports as Health, HealthController, Indexer_exports as Indexer, LLTV_exports as LLTV, Liquidity_exports as Liquidity, Logger_exports as Logger, Maturity_exports as Maturity, mempool_exports as Mempool, Obligation_exports as Obligation, ObligationResponse_exports as ObligationResponse, ObligationsController, Offer_exports as Offer, OfferResponse_exports as OfferResponse, OffersController, drizzle_exports as OffersSchema, OpenApi, Oracle_exports as Oracle, Position_exports as Position, PositionResponse_exports as PositionResponse, Quote_exports as Quote, RouterApi_exports as RouterApi, Client_exports$1 as RouterClient, RouterStatusResponse, Rules_exports as Rules, Tick_exports as Tick, time_exports as Time, TradingFee_exports as TradingFee, Transfer_exports as Transfer, Tree_exports as Tree, UsersController, utils_exports as Utils, ValidateController, Gate_exports as Validation, morphoRules, parse, safeParse };
+export { Abi_exports as Abi, BookResponse_exports as BookResponse, BooksController, BrandTypeId, Callback_exports as Callback, Chain_exports as Chain, ChainHealth, ChainRegistry_exports as ChainRegistry, ChainsHealthResponse, Collateral_exports as Collateral, CollectorHealth, CollectorsHealthResponse, ConfigContractsController, ConfigRulesController, Database_exports as Database, ERC4626_exports as ERC4626, Errors_exports as Errors, Format_exports as Format, Gatekeeper_exports as Gatekeeper, Client_exports as GatekeeperClient, Health_exports as Health, HealthController, Id_exports as Id, Indexer_exports as Indexer, LLTV_exports as LLTV, Liquidity_exports as Liquidity, Logger_exports as Logger, Maturity_exports as Maturity, mempool_exports as Mempool, Obligation_exports as Obligation, ObligationResponse_exports as ObligationResponse, ObligationsController, Offer_exports as Offer, OfferResponse_exports as OfferResponse, OffersController, drizzle_exports as OffersSchema, OpenApi, Oracle_exports as Oracle, Position_exports as Position, PositionResponse_exports as PositionResponse, Quote_exports as Quote, RouterApi_exports as RouterApi, Client_exports$1 as RouterClient, RouterStatusResponse, Rules_exports as Rules, Tick_exports as Tick, time_exports as Time, TradingFee_exports as TradingFee, Transfer_exports as Transfer, Tree_exports as Tree, UsersController, utils_exports as Utils, ValidateController, Gate_exports as Validation, morphoRules, parse, safeParse };
 //# sourceMappingURL=index.node.mjs.map