@morpho-dev/router 0.2.1 → 0.3.0

package/dist/cli.js

@@ -9,17 +9,15 @@ import { AWSXRayPropagator } from "@opentelemetry/propagator-aws-xray";
 import { resourceFromAttributes } from "@opentelemetry/resources";
 import { BatchSpanProcessor, NodeTracerProvider } from "@opentelemetry/sdk-trace-node";
 import { ATTR_SERVICE_NAME } from "@opentelemetry/semantic-conventions";
-import { createPublicClient, createTestClient, decodeAbiParameters, encodeAbiParameters, erc20Abi, getAddress, hashTypedData, hexToBytes, http, isAddress, isHex, keccak256, maxUint256, parseAbi, parseEventLogs, publicActions, stringify, toHex, walletActions, zeroAddress } from "viem";
+import { spawn } from "node:child_process";
+import { bytesToHex, createPublicClient, createTestClient, decodeAbiParameters, encodeAbiParameters, erc20Abi, getAddress, hashMessage, hashTypedData, hexToBytes, http, isAddress, isHex, keccak256, maxUint256, parseAbi, parseEventLogs, publicActions, recoverAddress, stringify, walletActions, zeroAddress } from "viem";
+import { privateKeyToAccount } from "viem/accounts";
 import { anvil, base, mainnet } from "viem/chains";
 import { getBlock, getBlockNumber, getLogs, multicall } from "viem/actions";
-import path from "node:path";
-import { fileURLToPath } from "node:url";
-import { spawn } from "node:child_process";
-import { generatePrivateKey, privateKeyToAccount } from "viem/accounts";
+import { readFile } from "node:fs/promises";
 import * as z$1 from "zod";
 import { StandardMerkleTree } from "@openzeppelin/merkle-tree";
-import { ungzip } from "pako";
-import { readFile } from "node:fs/promises";
+import { gzip, ungzip } from "pako";
 import { serve } from "@hono/node-server";
 import { Hono } from "hono";
 import { cors } from "hono/cors";
@@ -29,6 +27,8 @@ import "reflect-metadata";
 import { generateDocument } from "openapi-metadata";
 import { ApiBody, ApiOperation, ApiProperty, ApiQuery, ApiResponse, ApiTags } from "openapi-metadata/decorators";
 import { Base64 } from "js-base64";
+import path from "node:path";
+import { fileURLToPath } from "node:url";
 import dotenv from "dotenv";
 import { PGlite } from "@electric-sql/pglite";
 import { drizzle } from "drizzle-orm/node-postgres";
@@ -40,15 +40,7 @@ import { and, asc, desc, eq, gt, gte, inArray, lte, ne, sql } from "drizzle-orm"
 import { bigint, boolean, foreignKey, index, integer, numeric, pgSchema, primaryKey, serial, text, timestamp, uniqueIndex, varchar } from "drizzle-orm/pg-core";
 
 //#region rolldown:runtime
-var __create = Object.create;
 var __defProp = Object.defineProperty;
-var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
-var __getOwnPropNames = Object.getOwnPropertyNames;
-var __getProtoOf = Object.getPrototypeOf;
-var __hasOwnProp = Object.prototype.hasOwnProperty;
-var __esm = (fn, res) => function() {
-	return fn && (res = (0, fn[__getOwnPropNames(fn)[0]])(fn = 0)), res;
-};
 var __export = (all) => {
 	let target = {};
 	for (var name$1 in all) __defProp(target, name$1, {
@@ -57,21 +49,6 @@ var __export = (all) => {
 	});
 	return target;
 };
-var __copyProps = (to, from$15, except, desc$1) => {
-	if (from$15 && typeof from$15 === "object" || typeof from$15 === "function") for (var keys = __getOwnPropNames(from$15), i = 0, n = keys.length, key; i < n; i++) {
-		key = keys[i];
-		if (!__hasOwnProp.call(to, key) && key !== except) __defProp(to, key, {
-			get: ((k) => from$15[k]).bind(null, key),
-			enumerable: !(desc$1 = __getOwnPropDesc(from$15, key)) || desc$1.enumerable
-		});
-	}
-	return to;
-};
-var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", {
-	value: mod,
-	enumerable: true
-}) : target, mod));
-var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
 
 //#endregion
 //#region src/tracer/Tracer.ts
@@ -164,7 +141,7 @@ function startActiveSpan(tracer, name$1, fn) {
 //#endregion
 //#region package.json
 var name = "@morpho-dev/router";
-var version = "0.2.1";
+var version = "0.3.0";
 var description = "Router package for Morpho protocol";
 
 //#endregion
@@ -391,22 +368,22 @@ const DEFAULT_BATCH_SIZE$1 = 2500;
 const MAX_BLOCK_WINDOW = 1e4;
 const DEFAULT_BLOCK_WINDOW = 8e3;
 async function* streamLogs(parameters) {
-	const { client, contractAddress, event, blockNumberGte, blockNumberLte, order: order$1 = "desc", options: { maxBatchSize = DEFAULT_BATCH_SIZE$1, blockWindow = DEFAULT_BLOCK_WINDOW } = {} } = parameters;
+	const { client, contractAddress, event, blockNumberGte, blockNumberLte, order = "desc", options: { maxBatchSize = DEFAULT_BATCH_SIZE$1, blockWindow = DEFAULT_BLOCK_WINDOW } = {} } = parameters;
 	if (maxBatchSize > MAX_BATCH_SIZE) throw new InvalidBatchSizeError(maxBatchSize);
 	if (blockWindow > MAX_BLOCK_WINDOW) throw new InvalidBlockWindowError(blockWindow);
-	if (order$1 === "asc" && blockNumberGte === void 0) throw new MissingBlockNumberError();
+	if (order === "asc" && blockNumberGte === void 0) throw new MissingBlockNumberError();
 	const latestBlock = (await getBlock(client, {
 		blockTag: "latest",
 		includeTransactions: false
 	})).number;
 	let toBlock = 0n;
-	if (order$1 === "asc") toBlock = min(BigInt(blockNumberGte) + BigInt(blockWindow), blockNumberLte ? BigInt(blockNumberLte) : latestBlock);
-	if (order$1 === "desc") toBlock = blockNumberLte === void 0 ? latestBlock : min(BigInt(blockNumberLte), latestBlock);
+	if (order === "asc") toBlock = min(BigInt(blockNumberGte) + BigInt(blockWindow), blockNumberLte ? BigInt(blockNumberLte) : latestBlock);
+	if (order === "desc") toBlock = blockNumberLte === void 0 ? latestBlock : min(BigInt(blockNumberLte), latestBlock);
 	let fromBlock = 0n;
-	if (order$1 === "asc") fromBlock = min(BigInt(blockNumberGte), latestBlock);
-	if (order$1 === "desc") fromBlock = max(BigInt(blockNumberGte || toBlock - BigInt(blockWindow)), 0n);
-	if (order$1 === "asc") toBlock = min(toBlock, fromBlock + BigInt(blockWindow));
-	if (order$1 === "desc") fromBlock = max(fromBlock, toBlock - BigInt(blockWindow));
+	if (order === "asc") fromBlock = min(BigInt(blockNumberGte), latestBlock);
+	if (order === "desc") fromBlock = max(BigInt(blockNumberGte || toBlock - BigInt(blockWindow)), 0n);
+	if (order === "asc") toBlock = min(toBlock, fromBlock + BigInt(blockWindow));
+	if (order === "desc") fromBlock = max(fromBlock, toBlock - BigInt(blockWindow));
 	if (fromBlock > toBlock) throw new InvalidBlockRangeError(fromBlock, toBlock);
 	let streaming = true;
 	while (streaming) {
@@ -416,29 +393,29 @@ async function* streamLogs(parameters) {
 			fromBlock,
 			toBlock
 		});
-		streaming = order$1 === "asc" ? toBlock < (blockNumberLte || latestBlock) : fromBlock > (blockNumberGte || 0n);
+		streaming = order === "asc" ? toBlock < (blockNumberLte || latestBlock) : fromBlock > (blockNumberGte || 0n);
 		if (logs.length === 0 && !streaming) break;
 		if (logs.length === 0 && streaming) yield {
 			logs: [],
-			blockNumber: order$1 === "asc" ? Number(toBlock) : Number(fromBlock)
+			blockNumber: order === "asc" ? Number(toBlock) : Number(fromBlock)
 		};
 		logs.sort((a, b) => {
-			if (a.blockNumber !== b.blockNumber) return order$1 === "asc" ? Number(a.blockNumber - b.blockNumber) : Number(b.blockNumber - a.blockNumber);
-			if (a.transactionIndex !== b.transactionIndex) return order$1 === "asc" ? a.transactionIndex - b.transactionIndex : b.transactionIndex - a.transactionIndex;
-			return order$1 === "asc" ? a.logIndex - b.logIndex : b.logIndex - a.logIndex;
+			if (a.blockNumber !== b.blockNumber) return order === "asc" ? Number(a.blockNumber - b.blockNumber) : Number(b.blockNumber - a.blockNumber);
+			if (a.transactionIndex !== b.transactionIndex) return order === "asc" ? a.transactionIndex - b.transactionIndex : b.transactionIndex - a.transactionIndex;
+			return order === "asc" ? a.logIndex - b.logIndex : b.logIndex - a.logIndex;
 		});
 		for (const logBatch of batch$1(logs, maxBatchSize)) yield {
 			logs: logBatch,
-			blockNumber: logBatch.length === maxBatchSize ? Number(logBatch[logBatch.length - 1]?.blockNumber) : order$1 === "asc" ? Number(toBlock) : Number(fromBlock)
+			blockNumber: logBatch.length === maxBatchSize ? Number(logBatch[logBatch.length - 1]?.blockNumber) : order === "asc" ? Number(toBlock) : Number(fromBlock)
 		};
-		if (order$1 === "asc") {
+		if (order === "asc") {
 			const upperBound = BigInt(blockNumberLte || latestBlock);
 			const nextFromBlock = min(BigInt(toBlock) + 1n, upperBound);
 			const nextToBlock = min(toBlock + BigInt(blockWindow) + 1n, upperBound);
 			fromBlock = nextFromBlock;
 			toBlock = nextToBlock;
 		}
-		if (order$1 === "desc") {
+		if (order === "desc") {
 			const lowerBound = BigInt(blockNumberGte || 0);
 			const nextToBlock = max(fromBlock - 1n, lowerBound);
 			const nextFromBlock = max(fromBlock - BigInt(blockWindow) - 1n, lowerBound);
@@ -448,7 +425,7 @@ async function* streamLogs(parameters) {
 	}
 	yield {
 		logs: [],
-		blockNumber: order$1 === "asc" ? Number(toBlock) : Number(fromBlock)
+		blockNumber: order === "asc" ? Number(toBlock) : Number(fromBlock)
 	};
 }
 var InvalidBlockRangeError = class extends BaseError {
@@ -477,13 +454,77 @@ var MissingBlockNumberError = class extends BaseError {
 };
 
 //#endregion
-//#region ../../node_modules/.pnpm/tsdown@0.16.5_ms@2.1.3_typescript@5.8.3/node_modules/tsdown/esm-shims.js
-var getFilename, getDirname, __dirname;
-var init_esm_shims = __esm({ "../../node_modules/.pnpm/tsdown@0.16.5_ms@2.1.3_typescript@5.8.3/node_modules/tsdown/esm-shims.js": (() => {
-	getFilename = () => fileURLToPath(import.meta.url);
-	getDirname = () => path.dirname(getFilename());
-	__dirname = /* @__PURE__ */ getDirname();
-}) });
+//#region src/cli/commands/mempool.ts
+/** Default account for test transactions (first anvil account) */
+const testAccount = privateKeyToAccount("0xac0974bec39a17e36ba4a6b4d238ff944bacb478cbed5efcae784d7bf4f2ff80");
+/**
+* Start a local anvil chain.
+*/
+async function serve$2(parameters) {
+	const { port, forkUrl, blockNumber } = parameters;
+	let started = false;
+	const args = [
+		"--chain-id",
+		ChainId.ANVIL.toString(),
+		"--fork-url",
+		forkUrl,
+		"--port",
+		String(port)
+	];
+	if (blockNumber) args.push("--fork-block-number", String(blockNumber));
+	const stop = await new Promise((resolve, reject) => {
+		const subprocess = spawn("anvil", args, { env: {
+			...process.env,
+			FOUNDRY_DISABLE_NIGHTLY_WARNING: "1"
+		} });
+		subprocess.stdout.on("data", (data) => {
+			if (`[port ${port}] ${data.toString()}`.includes("Listening on")) {
+				started = true;
+				resolve(() => subprocess.kill("SIGINT"));
+			}
+		});
+		subprocess.stderr.on("data", (data) => {
+			const message = `[port ${port}] ${data.toString()}`;
+			console.warn(message);
+			if (!started) reject(message);
+			else console.warn(message);
+		});
+	});
+	return {
+		rpcUrl: `http://localhost:${port}`,
+		stop
+	};
+}
+const mempoolCmd = new Command("mempool");
+mempoolCmd.description("Start a local chain with the mempool contract").addOption(new Option("--port <port>").env("MEMPOOL_PORT").default(8545)).addOption(new Option("--fork-url <url>").env("MEMPOOL_FORK_URL").default("https://ethereum-rpc.publicnode.com")).addOption(new Option("--block-number <number>").default(0)).action(async (opts) => {
+	const { rpcUrl } = await serve$2({
+		port: opts.port,
+		forkUrl: opts.forkUrl,
+		blockNumber: opts.blockNumber
+	});
+	const client = createTestClient({
+		chain: {
+			...anvil,
+			id: Number(ChainId.ANVIL)
+		},
+		transport: http(rpcUrl),
+		mode: "anvil"
+	}).extend(publicActions).extend(walletActions);
+	const mempoolHash = await client.sendTransaction({
+		account: testAccount,
+		data: "0x60808060405234601357607d908160188239f35b5f80fdfe7f758c7cf107fab3cfdc5aefab966cd9e69c3f368761f7a218a18283c1fbb5574c60808060405260208152366020820152365f60408301375f604036830101526040817fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0601f3601168101030190a100fea164736f6c634300081e000a"
+	});
+	const { contractAddress: mempoolAddress } = await client.waitForTransactionReceipt({ hash: mempoolHash });
+	if (!mempoolAddress) throw new Error("Failed to deploy mempool contract");
+	console.log(`Mempool contract deployed at ${mempoolAddress}`);
+	const termsHash = await client.sendTransaction({
+		account: testAccount,
+		data: "0x6080604052348015600e575f5ffd5b506101dc8061001c5f395ff3fe608060405234801561000f575f5ffd5b5060043610610029575f3560e01c80637edab8a61461002d575b5f5ffd5b6100476004803603810190610042919061012e565b610049565b005b818373ffffffffffffffffffffffffffffffffffffffff167f1eed8a711368c40dda6427683883619012c34cf436e11e0d773b0d05169ccb8283604051610090919061018d565b60405180910390a3505050565b5f5ffd5b5f73ffffffffffffffffffffffffffffffffffffffff82169050919050565b5f6100ca826100a1565b9050919050565b6100da816100c0565b81146100e4575f5ffd5b50565b5f813590506100f5816100d1565b92915050565b5f819050919050565b61010d816100fb565b8114610117575f5ffd5b50565b5f8135905061012881610104565b92915050565b5f5f5f606084860312156101455761014461009d565b5b5f610152868287016100e7565b93505060206101638682870161011a565b92505060406101748682870161011a565b9150509250925092565b610187816100fb565b82525050565b5f6020820190506101a05f83018461017e565b9291505056fea2646970667358221220cc06296395b7aafdb892cd7bfe25a87dc6b35fe29b2d5cb2dcb3aad43050396a64736f6c634300081e0033"
+	});
+	const { contractAddress: termsAddress } = await client.waitForTransactionReceipt({ hash: termsHash });
+	if (!termsAddress) throw new Error("Failed to deploy terms contract");
+	console.log(`Terms contract deployed at ${termsAddress}`);
+});
 
 //#endregion
 //#region src/core/Abi/MetaMorpho.ts
@@ -562,6 +603,49 @@ function encodeSellERC20Callback(parameters) {
 	return encodeAbiParameters([{ type: "address[]" }, { type: "uint256[]" }], [parameters.collaterals, parameters.amounts]);
 }
 
+//#endregion
+//#region src/utils/Random.ts
+let currentRng = Math.random;
+/**
+* Returns a deterministic random float in [0, 1).
+*/
+function float() {
+	return currentRng();
+}
+/**
+* Returns a deterministic random integer in [min, maxExclusive).
+*/
+function int(maxExclusive, min$1 = 0) {
+	return Math.floor(float() * (maxExclusive - min$1)) + min$1;
+}
+/**
+* Returns a deterministic random boolean.
+*/
+function bool(probability = .5) {
+	return float() < probability;
+}
+/**
+* Returns deterministic random bytes.
+*/
+function bytes(length) {
+	const output = new Uint8Array(length);
+	for (let i = 0; i < length; i += 1) output[i] = int(256);
+	return output;
+}
+/**
+* Returns a deterministic random hex string for the given byte length.
+*/
+function hex(byteLength) {
+	const output = bytes(byteLength);
+	return `0x${Array.from(output, (byte) => byte.toString(16).padStart(2, "0")).join("")}`;
+}
+/**
+* Returns a deterministic random address.
+*/
+function address() {
+	return hex(20);
+}
+
 //#endregion
 //#region src/utils/zod.ts
 const transformHex = (val, ctx) => {
@@ -670,8 +754,8 @@ const from$13 = (parameters) => {
 */
 function random$1() {
 	return from$13({
-		asset: privateKeyToAccount(generatePrivateKey()).address,
-		oracle: privateKeyToAccount(generatePrivateKey()).address,
+		asset: address(),
+		oracle: address(),
 		lltv: .965
 	});
 }
@@ -976,48 +1060,191 @@ var CollateralsAreNotSortedError = class extends BaseError {
 //#endregion
 //#region src/core/Tree.ts
 const VERSION$1 = 1;
+const normalizeHash = (hash$1) => hash$1.toLowerCase();
 /**
 * Builds a Merkle tree from a list of offers.
 *
 * Leaves are the offer `hash` values as `bytes32` and are deterministically
-* ordered in ascending lexicographic order so that the resulting root is stable
-* regardless of the input order.
+* ordered following the StandardMerkleTree leaf ordering so that the resulting
+* root is stable regardless of the input order.
 *
 * @param offers - Offers to include in the tree.
 * @returns A `StandardMerkleTree` of `bytes32` leaves representing the offers.
+* @throws {TreeError} If tree building fails due to offer inconsistencies.
 */
 const from$10 = (offers$1) => {
-	const leaves = order(offers$1).map((offer) => {
-		return [offer.hash];
-	});
+	const leaves = offers$1.map((offer) => [offer.hash]);
 	const tree = StandardMerkleTree.of(leaves, ["bytes32"]);
-	return Object.assign(tree, { offers: offers$1 });
+	const orderedOffers = orderOffers(tree, offers$1);
+	return Object.assign(tree, { offers: orderedOffers });
+};
+const orderOffers = (tree, offers$1) => {
+	const offerByHash = /* @__PURE__ */ new Map();
+	for (const offer of offers$1) offerByHash.set(normalizeHash(offer.hash), offer);
+	const entries = tree.dump().values.map((value) => {
+		const hash$1 = normalizeHash(value.value[0]);
+		const offer = offerByHash.get(hash$1);
+		if (!offer) throw new TreeError(`missing offer for leaf ${hash$1}`);
+		return {
+			offer,
+			treeIndex: value.treeIndex
+		};
+	});
+	entries.sort((a, b) => b.treeIndex - a.treeIndex);
+	return entries.map((item) => item.offer);
+};
+/**
+* Generates merkle proofs for all offers in a tree.
+*
+* Each proof allows independent verification that an offer is included in the tree
+* without requiring the full tree. Proofs are ordered by StandardMerkleTree leaf ordering.
+*
+* @param tree - The {@link Tree} to generate proofs for.
+* @returns Array of proofs - {@link Proof}
+*/
+const proofs = (tree) => {
+	return tree.offers.map((offer) => {
+		return {
+			offer,
+			path: tree.getProof([offer.hash])
+		};
+	});
+};
+const assertHex = (value, expectedBytes, name$1) => {
+	if (typeof value !== "string" || !isHex(value)) throw new DecodeError(`${name$1} is not a valid hex string`);
+	if (hexToBytes(value).length !== expectedBytes) throw new DecodeError(`${name$1}: expected ${expectedBytes} bytes`);
+};
+const verifySignatureAndRecoverAddress = async (params) => {
+	const { root, signature } = params;
+	assertHex(signature, 65, "signature");
+	const hash$1 = hashMessage({ raw: root });
+	try {
+		return await recoverAddress({
+			hash: hash$1,
+			signature
+		});
+	} catch {
+		throw new DecodeError("signature recovery failed");
+	}
 };
-const byHashAsc = (a, b) => a.localeCompare(b);
-const order = (offers$1) => {
-	return offers$1.sort((a, b) => byHashAsc(a.hash, b.hash));
+/**
+* Encodes a merkle tree without a signature into hex payload for client-side signing.
+*
+* Layout: `0x{vv}{gzip([...offers])}{root}` where:
+* - `{vv}`: 1-byte version (currently 0x01)
+* - `{gzip([...offers])}`: gzipped JSON array of serialized offers
+* - `{root}`: 32-byte merkle root
+*
+* Validates root integrity before encoding.
+*
+* @param tree - Merkle tree of offers
+* @returns Hex-encoded unsigned payload
+* @throws {EncodeError} If root mismatch
+*/
+const encodeUnsigned = (tree) => {
+	validateTreeForEncoding(tree);
+	return bytesToHex(encodeUnsignedBytes(tree));
+};
+const validateTreeForEncoding = (tree) => {
+	if (VERSION$1 > 255) throw new EncodeError(`version overflow: ${VERSION$1} exceeds 255`);
+	const computed = from$10(tree.offers);
+	if (tree.root !== computed.root) throw new EncodeError(`root mismatch: expected ${computed.root}, got ${tree.root}`);
+};
+const encodeUnsignedBytes = (tree) => {
+	const offersPayload = tree.offers.map(serialize);
+	const compressed = gzip(JSON.stringify(offersPayload));
+	const rootBytes = hexToBytes(tree.root);
+	const encoded = new Uint8Array(1 + compressed.length + 32);
+	encoded[0] = VERSION$1;
+	encoded.set(compressed, 1);
+	encoded.set(rootBytes, 1 + compressed.length);
+	return encoded;
 };
 /**
-* Decodes a Hex string produced by {@link encode} back into an `Tree`.
+* Decodes hex calldata into a validated merkle tree.
+*
+* Validates signature before decompression for fail-fast rejection of invalid payloads.
+* Returns the tree with separately validated signature and recovered signer address.
 *
-* - Ensures the first byte version matches {@link VERSION}.
-* - Decompresses with gunzip, parses JSON, validates offers, and re-checks the root.
+* Validation order:
+* 1. Version check
+* 2. Signature verification (fail-fast, before decompression)
+* 3. Decompression (only if signature valid)
+* 4. Root verification (computed from offers vs embedded root)
 *
-* @param encoded - Hex string in the form `0x{vv}{zip...}`.
-* @returns A validated `Tree` rebuilt from the offers.
-* @throws Error if the version is invalid or the root does not match the offers.
+* @example
+* ```typescript
+* const { tree, signature, signer } = await Tree.decode(calldata);
+* console.log(`Tree signed by ${signer} with ${tree.offers.length} offers`);
+* ```
+*
+* @param encoded - Hex calldata in format `0x{vv}{gzip}{root}{signature}`
+* @returns Validated tree, signature, and recovered signer address
+* @throws {DecodeError} If version invalid, signature invalid, or root mismatch
+*/
+const decode$1 = async (encoded) => {
+	const bytes$1 = hexToBytes(encoded);
+	if (bytes$1.length < 98) throw new DecodeError("payload too short");
+	const version$1 = bytes$1[0];
+	if (version$1 !== (VERSION$1 & 255)) throw new DecodeError(`invalid version: expected ${VERSION$1}, got ${version$1 ?? 0}`);
+	const signature = bytesToHex(bytes$1.slice(-65));
+	const root = bytesToHex(bytes$1.slice(-97, -65));
+	assertHex(root, 32, "root");
+	assertHex(signature, 65, "signature");
+	const signer = await verifySignatureAndRecoverAddress({
+		root,
+		signature
+	});
+	const compressed = bytes$1.slice(1, -97);
+	let decoded;
+	try {
+		decoded = ungzip(compressed, { to: "string" });
+	} catch {
+		throw new DecodeError("decompression failed");
+	}
+	let rawOffers;
+	try {
+		rawOffers = JSON.parse(decoded);
+	} catch {
+		throw new DecodeError("JSON parse failed");
+	}
+	const tree = from$10(rawOffers.map((o) => OfferSchema().parse(o)));
+	if (root !== tree.root) throw new DecodeError(`root mismatch: expected ${tree.root}, got ${root}`);
+	return {
+		tree,
+		signature,
+		signer
+	};
+};
+/**
+* Error thrown during tree building operations.
+* Indicates structural issues with the tree (missing offers, inconsistent state).
 */
-const decode$1 = (encoded) => {
-	const bytes = hexToBytes(encoded);
-	if (bytes.length < 2) throw new Error("Invalid payload: too short");
-	const version$1 = bytes[0];
-	if (version$1 !== (VERSION$1 & 255)) throw new Error(`Invalid version: expected ${VERSION$1}, got ${version$1}`);
-	const decoded = ungzip(bytes.slice(1), { to: "string" });
-	const data = JSON.parse(decoded);
-	const root = data[0];
-	const tree = from$10(data.slice(1).map((o) => OfferSchema().parse(o)));
-	if (root !== tree.root) throw new Error(`Invalid root: expected ${tree.root}, got ${root}`);
-	return tree;
+var TreeError = class extends BaseError {
+	name = "Tree.TreeError";
+	constructor(reason) {
+		super(`Tree error: ${reason}`);
+	}
+};
+/**
+* Error thrown during tree encoding.
+* Indicates validation failures (signature, root mismatch, mixed makers).
+*/
+var EncodeError = class extends BaseError {
+	name = "Tree.EncodeError";
+	constructor(reason) {
+		super(`Failed to encode tree: ${reason}`);
+	}
+};
+/**
+* Error thrown during tree decoding.
+* Indicates payload corruption, version mismatch, or validation failures.
+*/
+var DecodeError = class extends BaseError {
+	name = "Tree.DecodeError";
+	constructor(reason) {
+		super(`Failed to decode tree: ${reason}`);
+	}
 };
 
 //#endregion
@@ -1089,16 +1316,47 @@ function fromSnakeCase(input) {
 	return from$9(fromSnakeCase$1(input));
 }
 /**
+* Serializes an offer for merkle tree encoding.
+* Converts BigInt fields to strings for JSON compatibility.
+*
+* @param offer - Offer to serialize
+* @returns JSON-serializable offer object
+*/
+const serialize = (offer) => ({
+	offering: offer.offering,
+	assets: offer.assets.toString(),
+	rate: offer.rate.toString(),
+	maturity: Number(offer.maturity),
+	expiry: Number(offer.expiry),
+	start: Number(offer.start),
+	nonce: offer.nonce.toString(),
+	buy: offer.buy,
+	chainId: offer.chainId,
+	loanToken: offer.loanToken,
+	collaterals: offer.collaterals.map((c) => ({
+		asset: c.asset,
+		oracle: c.oracle,
+		lltv: c.lltv.toString()
+	})),
+	callback: {
+		address: offer.callback.address,
+		data: offer.callback.data,
+		gasLimit: offer.callback.gasLimit.toString()
+	},
+	signature: offer.signature,
+	hash: offer.hash
+});
+/**
 * Generates a random Offer.
 * The returned Offer contains randomly generated values.
 * @warning The generated Offer should not be used for production usage.
 * @returns {Offer} A randomly generated Offer object.
 */
 function random(config) {
-	const chain = config?.chains ? config.chains[Math.floor(Math.random() * config.chains.length)] : chains$2.ethereum;
-	const loanToken = config?.loanTokens ? config.loanTokens[Math.floor(Math.random() * config.loanTokens.length)] : privateKeyToAccount(generatePrivateKey()).address;
-	const collateralCandidates = config?.collateralTokens ? config.collateralTokens.filter((a) => a !== loanToken) : [privateKeyToAccount(generatePrivateKey()).address];
-	const collateralAsset = collateralCandidates[Math.floor(Math.random() * collateralCandidates.length)];
+	const chain = config?.chains ? config.chains[int(config.chains.length)] : chains$2.ethereum;
+	const loanToken = config?.loanTokens ? config.loanTokens[int(config.loanTokens.length)] : address();
+	const collateralCandidates = config?.collateralTokens ? config.collateralTokens.filter((a) => a !== loanToken) : [address()];
+	const collateralAsset = collateralCandidates[int(collateralCandidates.length)];
 	const maturityOption = weightedChoice([["end_of_month", 1], ["end_of_next_month", 1]]);
 	const maturity$1 = config?.maturity ?? from$12(maturityOption);
 	const lltv = from$14(weightedChoice([
@@ -1112,7 +1370,7 @@ function random(config) {
 		[.965, 4],
 		[.98, 2]
 	]));
-	const buy = config?.buy !== void 0 ? config.buy : Math.random() > .5;
+	const buy = config?.buy !== void 0 ? config.buy : bool();
 	const ONE = 1000000000000000000n;
 	const qMin = buy ? 16 : 4;
 	const len = (buy ? 32 : 16) - qMin + 1;
@@ -1123,9 +1381,9 @@ function random(config) {
 	const rate = config?.rate ?? weightedChoice(ratePairs);
 	const loanTokenDecimals = config?.assetsDecimals?.[loanToken] ?? 18;
 	const unit = BigInt(10) ** BigInt(loanTokenDecimals);
-	const amountBase = BigInt(100 + Math.floor(Math.random() * 999901));
+	const amountBase = BigInt(100 + int(999901));
 	const assetsScaled = config?.assets ?? amountBase * unit;
-	const consumed = config?.consumed !== void 0 ? config.consumed : Math.random() < .8 ? 0n : assetsScaled * BigInt(1 + Math.floor(Math.random() * 900)) / 1000n;
+	const consumed = config?.consumed !== void 0 ? config.consumed : float() < .8 ? 0n : assetsScaled * BigInt(1 + int(900)) / 1000n;
 	const callbackBySide = (() => {
 		if (buy) return {
 			address: zeroAddress,
@@ -1144,29 +1402,29 @@ function random(config) {
 		};
 	})();
 	return from$9({
-		offering: config?.offering ?? privateKeyToAccount(generatePrivateKey()).address,
+		offering: config?.offering ?? address(),
 		assets: assetsScaled,
 		rate,
 		maturity: maturity$1,
 		expiry: config?.expiry ?? maturity$1 - 1,
 		start: config?.start ?? maturity$1 - 10,
-		nonce: BigInt(Math.floor(Math.random() * 1e6)),
+		nonce: BigInt(int(1e6)),
 		buy,
 		chainId: chain.id,
 		loanToken,
-		collaterals: config?.collaterals ?? Array.from({ length: Math.floor(Math.random() * 3) + 1 }, () => ({
+		collaterals: config?.collaterals ?? Array.from({ length: int(3) + 1 }, () => ({
 			...random$1(),
 			lltv
 		})).sort((a, b) => a.asset.localeCompare(b.asset)),
 		callback: config?.callback ?? callbackBySide,
 		consumed,
 		takeable: config?.takeable ?? assetsScaled - consumed,
-		blockNumber: config?.blockNumber ?? Math.floor(Math.random() * Number.MAX_SAFE_INTEGER)
+		blockNumber: config?.blockNumber ?? int(Number.MAX_SAFE_INTEGER)
 	});
 }
 const weightedChoice = (pairs) => {
 	const total = pairs.reduce((sum, [, weight]) => sum + weight, 0);
-	let roll = Math.random() * total;
+	let roll = float() * total;
 	for (const [value, weight] of pairs) {
 		roll -= weight;
 		if (roll < 0) return value;
@@ -1460,89 +1718,6 @@ function from$6(parameters) {
 //#region src/core/types.ts
 const BrandTypeId = Symbol.for("mempool/Brand");
 
-//#endregion
-//#region src/evm/EVM.ts
-const users = [privateKeyToAccount("0xac0974bec39a17e36ba4a6b4d238ff944bacb478cbed5efcae784d7bf4f2ff80")];
-const mockOracleAddress = privateKeyToAccount(keccak256(toHex("ORACLE"))).address;
-const mockMorphoAddress = privateKeyToAccount(keccak256(toHex("MORPHO"))).address;
-const mockFactoryAddress = privateKeyToAccount(keccak256(toHex("FACTORY"))).address;
-/**
-* Start a local anvil chain.
-* @example
-* ```ts
-* import { EVM } from "@morpho-dev/router";
-* EVM.serve(); // local chain rpc url running on http://localhost:8545
-* ```
-*/
-async function serve$2(parameters) {
-	const { port, forkUrl, blockNumber } = parameters;
-	let started = false;
-	const args = [
-		"--chain-id",
-		ChainId.ANVIL.toString(),
-		"--fork-url",
-		forkUrl,
-		"--port",
-		String(port)
-	];
-	if (blockNumber) args.push("--fork-block-number", String(blockNumber));
-	const stop = await new Promise((resolve, reject) => {
-		const subprocess = spawn("anvil", args, { env: {
-			...process.env,
-			FOUNDRY_DISABLE_NIGHTLY_WARNING: "1"
-		} });
-		subprocess.stdout.on("data", (data) => {
-			if (`[port ${port}] ${data.toString()}`.includes("Listening on")) {
-				started = true;
-				resolve(() => subprocess.kill("SIGINT"));
-			}
-		});
-		subprocess.stderr.on("data", (data) => {
-			const message = `[port ${port}] ${data.toString()}`;
-			console.warn(message);
-			if (!started) reject(message);
-			else console.warn(message);
-		});
-	});
-	return {
-		rpcUrl: `http://localhost:${port}`,
-		stop
-	};
-}
-
-//#endregion
-//#region src/cli/commands/mempool.ts
-const mempoolCmd = new Command("mempool");
-mempoolCmd.description("Start a local chain with the mempool contract").addOption(new Option("--port <port>").env("MEMPOOL_PORT").default(8545)).addOption(new Option("--fork-url <url>").env("MEMPOOL_FORK_URL").default("https://ethereum-rpc.publicnode.com")).addOption(new Option("--block-number <number>").default(0)).action(async (opts) => {
-	const { rpcUrl } = await serve$2({
-		port: opts.port,
-		forkUrl: opts.forkUrl,
-		blockNumber: opts.blockNumber
-	});
-	const client = createTestClient({
-		chain: {
-			...anvil,
-			id: Number(ChainId.ANVIL)
-		},
-		transport: http(rpcUrl),
-		mode: "anvil"
-	}).extend(publicActions).extend(walletActions);
-	const mempoolHash = await client.sendTransaction({
-		account: users[0],
-		data: "0x60808060405234601357607d908160188239f35b5f80fdfe7f758c7cf107fab3cfdc5aefab966cd9e69c3f368761f7a218a18283c1fbb5574c60808060405260208152366020820152365f60408301375f604036830101526040817fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0601f3601168101030190a100fea164736f6c634300081e000a"
-	});
-	const { contractAddress: mempoolAddress } = await client.waitForTransactionReceipt({ hash: mempoolHash });
-	if (!mempoolAddress) throw new Error("Failed to deploy mempool contract");
-	console.log(`Mempool contract deployed at ${mempoolAddress}`);
-	const termsHash = await client.sendTransaction({
-		account: users[0],
-		data: "0x6080604052348015600e575f5ffd5b506101dc8061001c5f395ff3fe608060405234801561000f575f5ffd5b5060043610610029575f3560e01c80637edab8a61461002d575b5f5ffd5b6100476004803603810190610042919061012e565b610049565b005b818373ffffffffffffffffffffffffffffffffffffffff167f1eed8a711368c40dda6427683883619012c34cf436e11e0d773b0d05169ccb8283604051610090919061018d565b60405180910390a3505050565b5f5ffd5b5f73ffffffffffffffffffffffffffffffffffffffff82169050919050565b5f6100ca826100a1565b9050919050565b6100da816100c0565b81146100e4575f5ffd5b50565b5f813590506100f5816100d1565b92915050565b5f819050919050565b61010d816100fb565b8114610117575f5ffd5b50565b5f8135905061012881610104565b92915050565b5f5f5f606084860312156101455761014461009d565b5b5f610152868287016100e7565b93505060206101638682870161011a565b92505060406101748682870161011a565b9150509250925092565b610187816100fb565b82525050565b5f6020820190506101a05f83018461017e565b9291505056fea2646970667358221220cc06296395b7aafdb892cd7bfe25a87dc6b35fe29b2d5cb2dcb3aad43050396a64736f6c634300081e0033"
-	});
-	const { contractAddress: termsAddress } = await client.waitForTransactionReceipt({ hash: termsHash });
-	if (!termsAddress) throw new Error("Failed to deploy terms contract");
-	console.log(`Terms contract deployed at ${termsAddress}`);
-});
-
 //#endregion
 //#region src/logger/Logger.ts
 const LogLevelValues = [
@@ -1670,13 +1845,16 @@ function from$4(obligation, quote) {
 * Creates an `OfferResponse` from an `Offer`.
 * @constructor
 * @param offer - {@link Offer}
+* @param attestation - {@link Attestation}
 * @returns The created `OfferResponse`. {@link OfferResponse}
 */
-function from$3(offer) {
-	const result = toSnakeCase(offer);
+function from$3(offer, attestation) {
+	const { signature: _, ...rest } = toSnakeCase(offer);
 	return {
-		...result,
-		signature: result.signature ?? null
+		...rest,
+		root: attestation?.root.toLowerCase() ?? null,
+		proof: attestation?.proof.map((p) => p.toLowerCase()) ?? null,
+		signature: attestation?.signature.toLowerCase() ?? null
 	};
 }
 
@@ -1814,10 +1992,12 @@ const offerExample = {
 		data: "0x00000000000000000000000000000000000000000000000000000000000000400000000000000000000000000000000000000000000000000000000000000080000000000000000000000000000000000000000000000000000000000000000100000000000000000000000034cf890db685fc536e05652fb41f02090c3fb751000000000000000000000000000000000000000000000000000000000000000100000000000000000000000000108e644e3ab01184155270aa92a00000000000",
 		gas_limit: "500000"
 	},
-	signature: "0x1234567890123456789012345678901234567890123456789012345678901234123456789012345678901234567890123456789012345678901234567890123400",
 	consumed: "0",
 	takeable: "369216000000000000000000",
-	block_number: 0xa7495128adfb1
+	block_number: 0xa7495128adfb1,
+	root: "0x1234567890abcdef1234567890abcdef1234567890abcdef1234567890abcdef",
+	proof: ["0xabcdef1234567890abcdef1234567890abcdef1234567890abcdef1234567890", "0x9876543210fedcba9876543210fedcba9876543210fedcba9876543210fedcba"],
+	signature: "0x1234567890123456789012345678901234567890123456789012345678901234123456789012345678901234567890123456789012345678901234567890123400"
 };
 const collectorsHealthExample = {
 	name: "offers",
@@ -1962,6 +2142,16 @@ __decorate([ApiProperty({
 	type: "number",
 	example: offerExample.block_number
 })], OfferListItemResponse.prototype, "block_number", void 0);
+__decorate([ApiProperty({
+	type: "string",
+	nullable: true,
+	example: offerExample.root
+})], OfferListItemResponse.prototype, "root", void 0);
+__decorate([ApiProperty({
+	type: [String],
+	nullable: true,
+	example: offerExample.proof
+})], OfferListItemResponse.prototype, "proof", void 0);
 __decorate([ApiProperty({
 	type: "string",
 	nullable: true,
@@ -2145,44 +2335,61 @@ __decorate([ApiProperty({
 var ValidateOffersRequest = class {};
 __decorate([ApiProperty({
 	type: () => [ValidateOfferRequest],
-	description: "Array of offers in snake_case format. Mutually exclusive with 'calldata'.",
-	required: false
+	description: "Array of offers in snake_case format. Required, non-empty.",
+	required: true
 })], ValidateOffersRequest.prototype, "offers", void 0);
+var ValidationSuccessDataResponse = class {};
 __decorate([ApiProperty({
 	type: "string",
-	description: "Encoded tree calldata as a hex string (0x-prefixed). Mutually exclusive with 'offers'.",
-	example: "0x01...",
-	required: false
-})], ValidateOffersRequest.prototype, "calldata", void 0);
-var ValidateOfferResultResponse = class {};
+	description: "Unsigned payload: version (1B) + gzip(offers) + root (32B).",
+	example: "0x01789c..."
+})], ValidationSuccessDataResponse.prototype, "payload", void 0);
 __decorate([ApiProperty({
 	type: "string",
-	example: offerExample.hash
-})], ValidateOfferResultResponse.prototype, "offer_hash", void 0);
+	description: "Merkle tree root to sign with EIP-191.",
+	example: "0xac4bd8318ec914f89f8af913f162230575b0ac0696a19256bc12138c5cfe1427"
+})], ValidationSuccessDataResponse.prototype, "root", void 0);
+var ValidationSuccessResponse = class extends SuccessResponse {};
 __decorate([ApiProperty({
-	type: "boolean",
-	example: false
-})], ValidateOfferResultResponse.prototype, "valid", void 0);
+	type: "string",
+	nullable: true,
+	example: null
+})], ValidationSuccessResponse.prototype, "cursor", void 0);
+__decorate([ApiProperty({
+	type: () => ValidationSuccessDataResponse,
+	description: "Payload and root for client-side signing."
+})], ValidationSuccessResponse.prototype, "data", void 0);
+var ValidationIssueResponse = class {};
+__decorate([ApiProperty({
+	type: "number",
+	description: "0-indexed position of the failed offer in the request array.",
+	example: 0
+})], ValidationIssueResponse.prototype, "index", void 0);
 __decorate([ApiProperty({
 	type: "string",
-	example: "parse_error",
-	nullable: true
-})], ValidateOfferResultResponse.prototype, "rule", void 0);
+	description: "Gatekeeper rule name that rejected the offer.",
+	example: "no_buy"
+})], ValidationIssueResponse.prototype, "rule", void 0);
 __decorate([ApiProperty({
 	type: "string",
-	example: "Invalid offer. 'offering': invalid address",
-	nullable: true
-})], ValidateOfferResultResponse.prototype, "message", void 0);
-var ValidateOffersListResponse = class extends SuccessResponse {};
+	description: "Human-readable rejection reason.",
+	example: "Buy offers are not supported"
+})], ValidationIssueResponse.prototype, "message", void 0);
+var ValidationFailureDataResponse = class {};
+__decorate([ApiProperty({
+	type: () => [ValidationIssueResponse],
+	description: "List of validation issues. Returned when any offer fails validation."
+})], ValidationFailureDataResponse.prototype, "issues", void 0);
+var ValidationFailureResponse = class extends SuccessResponse {};
 __decorate([ApiProperty({
 	type: "string",
 	nullable: true,
 	example: null
-})], ValidateOffersListResponse.prototype, "cursor", void 0);
+})], ValidationFailureResponse.prototype, "cursor", void 0);
 __decorate([ApiProperty({
-	type: () => [ValidateOfferResultResponse],
-	description: "Validation results for each offer."
-})], ValidateOffersListResponse.prototype, "data", void 0);
+	type: () => ValidationFailureDataResponse,
+	description: "List of validation issues. Returned when any offer fails validation."
+})], ValidationFailureResponse.prototype, "data", void 0);
 var BookLevelResponse = class {};
 __decorate([ApiProperty({
 	type: "string",
@@ -2247,13 +2454,18 @@ __decorate([
 		methods: ["post"],
 		path: "/v1/validate",
 		summary: "Validate offers",
-		description: "Validates offers against router validation rules. Returns validation status for each offer. Accepts either an array of offers or encoded calldata (mutually exclusive)."
+		description: "Validates offers against router validation rules. Returns unsigned payload + root on success, or issues only on validation failure."
 	}),
 	ApiBody({ type: ValidateOffersRequest }),
 	ApiResponse({
 		status: 200,
 		description: "Success",
-		type: ValidateOffersListResponse
+		type: ValidationSuccessResponse
+	}),
+	ApiResponse({
+		status: 200,
+		description: "Validation issues",
+		type: ValidationFailureResponse
 	})
 ], ValidateController.prototype, "validateOffers", null);
 ValidateController = __decorate([ApiTags("Validate"), ApiResponse({
@@ -2422,27 +2634,33 @@ const OpenApi = async (options = {}) => {
 	if (options.rules && options.rules.length > 0) {
 		const rulesDescription = options.rules.map((rule) => `- **${rule.name}**: ${rule.description}`).join("\n");
 		const validatePath = document.paths?.["/v1/validate"];
-		if (validatePath && "post" in validatePath && validatePath.post) validatePath.post.description = `Validates offers against router validation rules. Returns validation status for each offer.\n\n**Available validation rules:**\n${rulesDescription}`;
+		if (validatePath && "post" in validatePath && validatePath.post) validatePath.post.description = `Validates offers against router validation rules. Returns unsigned payload + root on success, or issues only on validation failure.\n\n**Available validation rules:**\n${rulesDescription}`;
 	}
 	return document;
 };
 
 //#endregion
 //#region src/database/utils/Cursor.ts
-function validate(cursor) {
-	if (!cursor || typeof cursor !== "object") throw new Error("Cursor must be an object");
-	const c = cursor;
-	if (![
+const isSort = (value) => {
+	return [
 		"rate",
 		"maturity",
 		"expiry",
 		"amount"
-	].includes(c.sort)) throw new Error(`Invalid sort field: ${c.sort}. Must be one of: rate, maturity, expiry, amount`);
-	if (!["asc", "desc"].includes(c.dir)) throw new Error(`Invalid direction: ${c.dir}. Must be one of: asc, desc`);
-	if (!/^0x[a-fA-F0-9]{64}$/.test(c.hash)) throw new Error(`Invalid hash format: ${c.hash}. Must be a 64-character hex string starting with 0x`);
-	const validation = {
-		rate: {
-			field: "rate",
+	].includes(value);
+};
+function validate(cursor) {
+	if (!cursor || typeof cursor !== "object") throw new Error("Cursor must be an object");
+	const c = cursor;
+	const sort = c.sort;
+	const dir = c.dir;
+	const hash$1 = c.hash;
+	if (typeof sort !== "string" || !isSort(sort)) throw new Error(`Invalid sort field: ${String(sort)}. Must be one of: rate, maturity, expiry, amount`);
+	if (typeof dir !== "string" || !["asc", "desc"].includes(dir)) throw new Error(`Invalid direction: ${String(dir)}. Must be one of: asc, desc`);
+	if (typeof hash$1 !== "string" || !/^0x[a-fA-F0-9]{64}$/.test(hash$1)) throw new Error(`Invalid hash format: ${String(hash$1)}. Must be a 64-character hex string starting with 0x`);
+	const validation = {
+		rate: {
+			field: "rate",
 			type: "string",
 			pattern: /^\d+$/,
 			error: "numeric string"
@@ -2456,24 +2674,30 @@ function validate(cursor) {
 		maturity: {
 			field: "maturity",
 			type: "number",
-			validator: (val) => val > 0,
+			min: 1,
 			error: "positive number"
 		},
 		expiry: {
 			field: "expiry",
 			type: "number",
-			validator: (val) => val > 0,
+			min: 1,
 			error: "positive number"
 		}
-	}[c.sort];
-	if (!validation) throw new Error(`Invalid sort field: ${c.sort}`);
+	}[sort];
+	if (!validation) throw new Error(`Invalid sort field: ${sort}`);
 	const fieldValue = c[validation.field];
-	if (!fieldValue) throw new Error(`${c.sort} sort requires '${validation.field}' field to be present`);
-	if (typeof fieldValue !== validation.type) throw new Error(`${c.sort} sort requires '${validation.field}' field of type ${validation.type}`);
-	if (validation.pattern && !validation.pattern.test(fieldValue)) throw new Error(`Invalid ${validation.field} format: ${fieldValue}. Must be a ${validation.error}`);
-	if (validation.validator && !validation.validator(fieldValue)) throw new Error(`Invalid ${validation.field} value: ${fieldValue}. Must be a ${validation.error}`);
-	if (c.page !== void 0) {
-		if (typeof c.page !== "number" || !Number.isInteger(c.page) || c.page < 1) throw new Error("Invalid page: must be a positive integer");
+	if (fieldValue === void 0 || fieldValue === null) throw new Error(`${sort} sort requires '${validation.field}' field to be present`);
+	if (validation.type === "string") {
+		if (typeof fieldValue !== "string") throw new Error(`${sort} sort requires '${validation.field}' field of type ${validation.type}`);
+		if (!validation.pattern.test(fieldValue)) throw new Error(`Invalid ${validation.field} format: ${fieldValue}. Must be a ${validation.error}`);
+	}
+	if (validation.type === "number") {
+		if (typeof fieldValue !== "number") throw new Error(`${sort} sort requires '${validation.field}' field of type ${validation.type}`);
+		if (fieldValue < validation.min) throw new Error(`Invalid ${validation.field} value: ${fieldValue}. Must be a ${validation.error}`);
+	}
+	const page = c.page;
+	if (page !== void 0) {
+		if (typeof page !== "number" || !Number.isInteger(page) || page < 1) throw new Error("Invalid page: must be a positive integer");
 	}
 	return true;
 }
@@ -2586,21 +2810,7 @@ const schemas = {
 	get_obligations: GetObligationsQueryParams,
 	get_obligation: GetObligationParams,
 	get_book: GetBookParams,
-	validate_offers: z$1.object({
-		offers: z$1.any().refine((val) => val === void 0 || Array.isArray(val), { message: "'offers' must be an array" }),
-		calldata: z$1.string().regex(/^0x[a-fA-F0-9]*$/, { message: "'calldata' must be a hex string starting with '0x'" }).optional()
-	}).superRefine((val, ctx) => {
-		const hasOffers = val.offers !== void 0;
-		const hasCalldata = val.calldata !== void 0;
-		if (hasOffers && hasCalldata) ctx.addIssue({
-			code: "custom",
-			message: "Request body must contain either 'offers' or 'calldata', not both"
-		});
-		if (!hasOffers && !hasCalldata) ctx.addIssue({
-			code: "custom",
-			message: "Request body must contain either 'offers' array or 'calldata' hex string"
-		});
-	})
+	validate_offers: z$1.object({ offers: z$1.array(z$1.unknown()).min(1, { message: "'offers' must contain at least 1 offer" }) }).strict()
 };
 function safeParse(action, query, error) {
 	return schemas[action].safeParse(query, { error });
@@ -2725,7 +2935,7 @@ function now() {
 
 //#endregion
 //#region src/indexer/collectors/Admin.ts
-function create$14(parameters) {
+function create$17(parameters) {
 	const collector = "admin";
 	const { client, db, options: { maxBatchSize = 25, maxBlockNumber } = {} } = parameters;
 	const maxBlockNumberBI = maxBlockNumber !== void 0 ? BigInt(maxBlockNumber) : void 0;
@@ -2974,8 +3184,8 @@ const names = [
 	"positions",
 	"prices"
 ];
-function create$13({ name: name$1, collect, client, db, options }) {
-	const admin = create$14({
+function create$16({ name: name$1, collect, client, db, options }) {
+	const admin = create$17({
 		client,
 		db,
 		options
@@ -3025,7 +3235,10 @@ function create$13({ name: name$1, collect, client, db, options }) {
 					};
 				});
 				if (done) iterator = null;
-				else yield blockNumber;
+				else {
+					lastBlockNumber = blockNumber;
+					yield blockNumber;
+				}
 			} catch (err) {
 				const isError = err instanceof Error;
 				logger.error({
@@ -3183,30 +3396,79 @@ async function* collectOffersV2(parameters) {
 	});
 	for await (const { logs, blockNumber: lastStreamBlockNumber } of stream) {
 		blockNumber = lastStreamBlockNumber;
-		const offers$1 = [];
+		const decodedTrees = [];
 		for (const log of logs) {
 			if (!log) continue;
 			const [payload] = decodeAbiParameters([{ type: "bytes" }], log.data);
 			try {
-				const tree = decode$1(payload);
-				for (const offer of tree.offers) offers$1.push({
+				const { tree, signature, signer } = await decode$1(payload);
+				const signerMismatch = tree.offers.find((offer) => offer.offering.toLowerCase() !== signer.toLowerCase());
+				if (signerMismatch) {
+					logger.debug({
+						msg: "Tree rejected: signer mismatch",
+						reason: "signer_mismatch",
+						signer,
+						offering: signerMismatch.offering,
+						chain_id: client.chain.id
+					});
+					continue;
+				}
+				const offersWithBlock = tree.offers.map((offer) => ({
 					...offer,
 					blockNumber: Number(log.blockNumber)
+				}));
+				const treeWithBlock = Object.assign(Object.create(Object.getPrototypeOf(tree)), tree, { offers: offersWithBlock });
+				decodedTrees.push({
+					tree: treeWithBlock,
+					signature,
+					signer,
+					blockNumber: Number(log.blockNumber)
+				});
+			} catch (err) {
+				const reason = err instanceof DecodeError && err.message.includes("signature") ? "invalid_signature" : "decode_failed";
+				logger.debug({
+					msg: "Tree decode failed",
+					reason,
+					chain_id: client.chain.id,
+					err: err instanceof Error ? err.message : String(err)
 				});
-			} catch (_) {}
+			}
 		}
 		await db.transaction(async (dbTx) => {
 			const { epoch, blockNumber: latestBlockNumber } = await dbTx.chains.getBlockNumber(client.chain.id);
-			let validOffers = [];
-			try {
-				validOffers = (await gatekeeper.isAllowed(offers$1)).valid.filter((offer) => offer.blockNumber <= latestBlockNumber);
+			const treesToInsert = [];
+			let totalValidOffers = 0;
+			for (const { tree, signature } of decodedTrees) try {
+				const allowedResults = await gatekeeper.isAllowed(tree.offers);
+				const hasBlockWindowViolation = tree.offers.some((offer) => offer.blockNumber > latestBlockNumber);
+				if (!(allowedResults.issues.length === 0 && allowedResults.valid.length === tree.offers.length) || hasBlockWindowViolation) {
+					if (allowedResults.issues.length > 0) {
+						const hasMixedMaker = allowedResults.issues.some((i) => i.ruleName === "mixed_maker");
+						logger.debug({
+							msg: "Tree offers rejected by gatekeeper",
+							reason: hasMixedMaker ? "mixed_maker" : "gatekeeper_rejected",
+							chain_id: client.chain.id,
+							issues_count: allowedResults.issues.length
+						});
+					} else if (hasBlockWindowViolation) logger.debug({
+						msg: "Tree rejected: offers outside block window",
+						reason: "block_window",
+						chain_id: client.chain.id
+					});
+					continue;
+				}
+				treesToInsert.push({
+					tree,
+					signature
+				});
+				totalValidOffers += tree.offers.length;
 			} catch (err) {
 				logger.error({
 					err,
-					msg: "Failed to validate offers"
+					msg: "Failed to validate offers for tree"
 				});
 			}
-			await dbTx.offers.create(validOffers);
+			if (treesToInsert.length > 0) await dbTx.trees.create(treesToInsert);
 			try {
 				await dbTx.collectors.saveBlockNumber({
 					collectorName: collector,
@@ -3214,10 +3476,11 @@ async function* collectOffersV2(parameters) {
 					blockNumber,
 					epoch
 				});
-				if (validOffers.length > 0) logger.info({
+				if (totalValidOffers > 0) logger.info({
 					msg: `New offers`,
 					collector,
-					count: validOffers.length,
+					count: totalValidOffers,
+					trees_count: treesToInsert.length,
 					chain_id: client.chain.id,
 					block_range: [startBlock, lastStreamBlockNumber]
 				});
@@ -3860,7 +4123,7 @@ async function* collectPrices(parameters) {
 //#region src/indexer/collectors/CollectorBuilder.ts
 function createBuilder(parameters) {
 	const { client, db, gatekeeper, options: { maxBlockNumber, blockWindow } = {} } = parameters;
-	const createCollector = (name$1, collect) => create$13({
+	const createCollector = (name$1, collect) => create$16({
 		name: name$1,
 		collect,
 		client,
@@ -3959,7 +4222,7 @@ function from$1(config) {
 		retryAttempts,
 		retryDelayMs
 	});
-	return create$12({
+	return create$15({
 		db,
 		client,
 		collectors: [
@@ -3971,7 +4234,7 @@ function from$1(config) {
 		interval
 	});
 }
-function create$12(params) {
+function create$15(params) {
 	const { db, collectors: collectors$1, interval, client } = params;
 	const logger = getLogger();
 	const indexerId = `${client.chain.id.toString()}.indexer`;
@@ -4032,7 +4295,7 @@ const DEFAULT_MAX_ALLOWED_LAG = 5;
 /**
 * Create a health service that exposes collector and chain block numbers.
 */
-function create$11(parameters) {
+function create$14(parameters) {
 	const { db, maxAllowedLag = DEFAULT_MAX_ALLOWED_LAG, healthClients } = parameters;
 	const loadSnapshot = async () => {
 		const [collectorRows, chainRows, remoteBlockByChainId] = await Promise.all([
@@ -4124,7 +4387,7 @@ async function getRemoteBlockNumbers(healthClients) {
 async function getHealth(db) {
 	const logger = getLogger();
 	try {
-		const status$1 = await create$11({ db }).getStatus();
+		const status$1 = await create$14({ db }).getStatus();
 		return success({ data: toSnakeCase({ status: status$1 }) });
 	} catch (err) {
 		logger.error({
@@ -4139,7 +4402,7 @@ async function getHealth(db) {
 async function getHealthChains(db, healthClients) {
 	const logger = getLogger();
 	try {
-		const chains$3 = await create$11({
+		const chains$3 = await create$14({
 			db,
 			healthClients
 		}).getChains();
@@ -4162,7 +4425,7 @@ async function getHealthChains(db, healthClients) {
 async function getHealthCollectors(db) {
 	const logger = getLogger();
 	try {
-		const collectors$1 = await create$11({ db }).getCollectors();
+		const collectors$1 = await create$14({ db }).getCollectors();
 		return success({ data: collectors$1.map(({ name: name$1, chainId, blockNumber, updatedAt, lag, status: status$1 }) => toSnakeCase({
 			name: name$1,
 			chainId,
@@ -4263,8 +4526,10 @@ async function getOffers(queryParameters, db) {
 			cursor: query.cursor,
 			limit: query.limit
 		});
+		const hashes = offers$1.map((offer) => offer.hash);
+		const attestationMap = await db.trees.getAttestations(hashes);
 		return success({
-			data: offers$1.map(from$3),
+			data: offers$1.map((offer) => from$3(offer, attestationMap.get(offer.hash.toLowerCase()))),
 			cursor: nextCursor ?? null
 		});
 	} catch (err) {
@@ -4284,56 +4549,49 @@ async function validateOffers(body, gatekeeper) {
 	const logger = getLogger();
 	const result = safeParse("validate_offers", body, (issue) => issue.message);
 	if (!result.success) return failure(new BadRequestError(result.error.issues[0]?.message ?? "Invalid request body"));
-	const { offers: rawOffers, calldata } = result.data;
-	const results = [];
+	const { offers: rawOffers } = result.data;
 	const parsedOffers = [];
-	const parsedOfferIndices = [];
-	const hasOffers = rawOffers !== void 0;
-	if (calldata !== void 0) try {
-		const tree = decode$1(calldata);
-		for (const [i, offer] of tree.offers.entries()) {
-			parsedOffers.push(offer);
-			parsedOfferIndices.push(i);
-		}
-	} catch (err) {
-		const message = err instanceof Error ? err.message : String(err);
-		return failure(new BadRequestError(`Failed to decode calldata: ${message}`));
-	}
-	if (hasOffers) for (let i = 0; i < rawOffers.length; i++) {
+	const offerIndexByHash = /* @__PURE__ */ new Map();
+	for (let i = 0; i < rawOffers.length; i++) {
 		const rawOffer = rawOffers[i];
 		try {
 			const offer = fromSnakeCase(rawOffer);
-			parsedOffers.push(offer);
-			parsedOfferIndices.push(i);
+			if (!offerIndexByHash.has(offer.hash)) {
+				offerIndexByHash.set(offer.hash, i);
+				parsedOffers.push(offer);
+			}
 		} catch (err) {
 			let message = err instanceof Error ? err.message : String(err);
 			if (err instanceof InvalidOfferError) message = err.formattedMessage;
-			results[i] = {
-				offer_hash: rawOffer?.hash ?? "unknown",
-				valid: false,
-				rule: "parse_error",
-				message
-			};
+			return failure(new BadRequestError(`Offer at index ${i} failed to parse: ${message}`));
 		}
 	}
-	if (parsedOffers.length > 0) try {
-		const { valid, issues } = await gatekeeper.isAllowed(parsedOffers);
-		for (const offer of valid) {
-			const originalIndex = parsedOfferIndices[parsedOffers.indexOf(offer)];
-			if (originalIndex !== void 0) results[originalIndex] = {
-				offer_hash: offer.hash,
-				valid: true
-			};
-		}
-		for (const issue of issues) {
-			const originalIndex = parsedOfferIndices[parsedOffers.indexOf(issue.item)];
-			if (originalIndex !== void 0) results[originalIndex] = {
-				offer_hash: issue.item.hash,
-				valid: false,
-				rule: issue.ruleName,
-				message: issue.message
-			};
+	try {
+		const { issues } = await gatekeeper.isAllowed(parsedOffers);
+		if (issues.length > 0) {
+			const mappedIssues = issues.map((issue) => {
+				const index$1 = offerIndexByHash.get(issue.item.hash);
+				if (index$1 === void 0) return null;
+				return {
+					index: index$1,
+					rule: issue.ruleName,
+					message: issue.message
+				};
+			}).filter((issue) => issue !== null);
+			return success({
+				data: { issues: mappedIssues },
+				cursor: null
+			});
 		}
+		const tree = from$10(parsedOffers);
+		const payload = encodeUnsigned(tree);
+		return success({
+			data: {
+				payload,
+				root: tree.root
+			},
+			cursor: null
+		});
 	} catch (err) {
 		logger.error({
 			err,
@@ -4343,24 +4601,19 @@ async function validateOffers(body, gatekeeper) {
 		});
 		return failure(err);
 	}
-	const orderedResults = results.filter((r) => r !== void 0);
-	return success({
-		data: orderedResults,
-		cursor: null
-	});
 }
 
 //#endregion
 //#region src/api/Api.ts
 function from(config) {
 	const { db, gatekeeper, port } = config;
-	return create$10({
+	return create$13({
 		port,
 		db,
 		gatekeeper
 	});
 }
-function create$10(params) {
+function create$13(params) {
 	return { serve: () => serve$1(params) };
 }
 /**
@@ -4454,6 +4707,21 @@ function single(name$1, description$1, run$1) {
 		run: run$1
 	};
 }
+/**
+* Create a validation rule iterating over a batch of items at a time.
+* @param name - The name of the rule.
+* @param description - A human-readable description of the rule.
+* @param run - The function that validates the rule.
+* @returns The created rule.
+*/
+function batch(name$1, description$1, run$1) {
+	return {
+		kind: "batch",
+		name: name$1,
+		description: description$1,
+		run: run$1
+	};
+}
 async function run(parameters) {
 	const { items, rules, chunkSize } = parameters;
 	const issues = [];
@@ -4504,7 +4772,7 @@ async function run(parameters) {
 
 //#endregion
 //#region src/gatekeeper/Gatekeeper.ts
-function create$9(parameters) {
+function create$12(parameters) {
 	return {
 		rules: parameters.rules,
 		isAllowed: async (offers$1) => {
@@ -4526,8 +4794,8 @@ function create$9(parameters) {
 * @param address - Callback contract address
 * @returns The callback type when found, otherwise undefined
 */
-function getCallbackType(chain, address) {
-	return configs[chain].callbacks?.find((c) => c.type !== CallbackType.BuyWithEmptyCallback && c.addresses.includes(address?.toLowerCase()))?.type;
+function getCallbackType(chain, address$1) {
+	return configs[chain].callbacks?.find((c) => c.type !== CallbackType.BuyWithEmptyCallback && c.addresses.includes(address$1?.toLowerCase()))?.type;
 }
 /**
 * Returns the list of allowed non-empty callback addresses for a chain.
@@ -4656,10 +4924,29 @@ const token = ({ assets: assets$1 }) => single("token", "Validates that offer lo
 	if (!allowedAssets.includes(offer.loanToken.toLowerCase())) return { message: "Loan token is not allowed" };
 	if (offer.collaterals.some((collateral) => !allowedAssets.includes(collateral.asset.toLowerCase()))) return { message: "Collateral is not allowed" };
 });
+/**
+* A batch validation rule that ensures all offers in a tree have the same maker (offering address).
+* Returns an issue only for the first non-conforming offer.
+* This rule is signing-agnostic; signer verification is handled at the collector level.
+*/
+const sameMaker = () => batch("mixed_maker", "Validates that all offers in a batch have the same maker (offering address)", (offers$1) => {
+	const issues = /* @__PURE__ */ new Map();
+	if (offers$1.length === 0) return issues;
+	const firstMaker = offers$1[0].offering.toLowerCase();
+	for (let i = 1; i < offers$1.length; i++) {
+		const offer = offers$1[i];
+		if (offer.offering.toLowerCase() !== firstMaker) {
+			issues.set(i, { message: `Offer has different maker ${offer.offering} than first offer ${offers$1[0].offering}` });
+			return issues;
+		}
+	}
+	return issues;
+});
 
 //#endregion
 //#region src/gatekeeper/morphoRules.ts
 const morphoRules = (chains$3) => [
+	sameMaker(),
 	chains$1({ chains: chains$3 }),
 	maturity({ maturities: [MaturityType.EndOfMonth, MaturityType.EndOfNextMonth] }),
 	callback({
@@ -4673,6 +4960,12 @@ const morphoRules = (chains$3) => [
 	token({ assets: chains$3.flatMap((c) => assets[c.id.toString()] ?? []) })
 ];
 
+//#endregion
+//#region ../../node_modules/.pnpm/tsdown@0.16.5_ms@2.1.3_typescript@5.8.3/node_modules/tsdown/esm-shims.js
+const getFilename = () => fileURLToPath(import.meta.url);
+const getDirname = () => path.dirname(getFilename());
+const __dirname = /* @__PURE__ */ getDirname();
+
 //#endregion
 //#region src/database/drizzle/VERSION.ts
 const VERSION = "router_v1.6";
@@ -4689,15 +4982,19 @@ var schema_exports = /* @__PURE__ */ __export({
 	collectors: () => collectors,
 	consumedEvents: () => consumedEvents,
 	groups: () => groups,
+	lots: () => lots,
+	merklePaths: () => merklePaths,
 	obligationCollateralsV2: () => obligationCollateralsV2,
 	obligations: () => obligations,
 	offers: () => offers,
 	offersCallbacks: () => offersCallbacks,
+	offsets: () => offsets,
 	oracles: () => oracles,
 	positionTypes: () => positionTypes,
 	positions: () => positions,
 	status: () => status,
 	transfers: () => transfers,
+	trees: () => trees,
 	validations: () => validations
 });
 const s = pgSchema(VERSION);
@@ -4715,6 +5012,10 @@ var EnumTableName = /* @__PURE__ */ function(EnumTableName$1) {
 	EnumTableName$1["VALIDATIONS"] = "validations";
 	EnumTableName$1["COLLECTORS"] = "collectors";
 	EnumTableName$1["CHAINS"] = "chains";
+	EnumTableName$1["LOTS"] = "lots";
+	EnumTableName$1["OFFSETS"] = "offsets";
+	EnumTableName$1["TREES"] = "trees";
+	EnumTableName$1["MERKLE_PATHS"] = "merkle_paths";
 	return EnumTableName$1;
 }(EnumTableName || {});
 const TABLE_NAMES = Object.values(EnumTableName);
@@ -4877,6 +5178,86 @@ const callbacks = s.table(EnumTableName.CALLBACKS, {
 	],
 	name: "callbacks_positions_fk"
 }).onDelete("cascade")]);
+const lots = s.table(EnumTableName.LOTS, {
+	chainId: bigint("chain_id", { mode: "number" }).$type().notNull(),
+	user: varchar("user", { length: 42 }).notNull(),
+	contract: varchar("contract", { length: 42 }).notNull(),
+	group: varchar("group", { length: 66 }).notNull(),
+	lower: numeric("lower", {
+		precision: 78,
+		scale: 0
+	}).notNull(),
+	upper: numeric("upper", {
+		precision: 78,
+		scale: 0
+	}).notNull()
+}, (table) => [
+	primaryKey({
+		columns: [
+			table.chainId,
+			table.user,
+			table.contract,
+			table.group
+		],
+		name: "lots_pk"
+	}),
+	foreignKey({
+		columns: [
+			table.chainId,
+			table.contract,
+			table.user
+		],
+		foreignColumns: [
+			positions.chainId,
+			positions.contract,
+			positions.user
+		],
+		name: "lots_positions_fk"
+	}).onDelete("cascade"),
+	foreignKey({
+		columns: [
+			table.chainId,
+			table.user,
+			table.group
+		],
+		foreignColumns: [
+			groups.chainId,
+			groups.maker,
+			groups.group
+		],
+		name: "lots_groups_fk"
+	}).onDelete("cascade")
+]);
+const offsets = s.table(EnumTableName.OFFSETS, {
+	chainId: bigint("chain_id", { mode: "number" }).$type().notNull(),
+	user: varchar("user", { length: 42 }).notNull(),
+	contract: varchar("contract", { length: 42 }).notNull(),
+	group: varchar("group", { length: 66 }).notNull(),
+	value: numeric("value", {
+		precision: 78,
+		scale: 0
+	}).notNull()
+}, (table) => [primaryKey({
+	columns: [
+		table.chainId,
+		table.user,
+		table.contract,
+		table.group
+	],
+	name: "offsets_pk"
+}), foreignKey({
+	columns: [
+		table.chainId,
+		table.contract,
+		table.user
+	],
+	foreignColumns: [
+		positions.chainId,
+		positions.contract,
+		positions.user
+	],
+	name: "offsets_positions_fk"
+}).onDelete("cascade")]);
 const PositionTypes = s.enum("position_type", Object.values(Type));
 const positionTypes = s.table("position_types", {
 	id: serial("id").primaryKey(),
@@ -4972,12 +5353,23 @@ const chains = s.table(EnumTableName.CHAINS, {
 	}).default("0").notNull(),
 	updatedAt: timestamp("updated_at").defaultNow().notNull()
 }, (table) => [uniqueIndex("chains_id_epoch_idx").on(table.chainId, table.epoch)]);
+const trees = s.table(EnumTableName.TREES, {
+	root: varchar("root", { length: 66 }).primaryKey(),
+	rootSignature: varchar("root_signature", { length: 132 }).notNull(),
+	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" }),
+	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)]);
 
 //#endregion
 //#region src/database/domains/Book.ts
 const DEFAULT_LIMIT$3 = 100;
 const MAX_TOTAL_OFFERS = 500;
-function create$8(config) {
+function create$11(config) {
 	const db = config.db;
 	const logger = getLogger();
 	const getOffers$1 = async (parameters) => {
@@ -4996,52 +5388,20 @@ function create$8(config) {
 			offers: [],
 			nextCursor: null
 		};
-		const effectiveLimit = Math.min(requestedLimit, MAX_TOTAL_OFFERS - previouslyReturned);
-		const book = [];
-		const prices = /* @__PURE__ */ new Map();
-		const callbackState = /* @__PURE__ */ new Map();
-		const positionState = /* @__PURE__ */ new Map();
-		let offerCursor = null;
-		let hasMoreOffers = false;
-		while (book.length < effectiveLimit) {
-			const batchSize = (effectiveLimit - book.length) * 2;
-			const { offers: rawOffers, nextCursor: rawNextCursor } = await _getOffersWithCallbackIds(db, {
-				obligationId: obligationId$1,
-				side,
-				now: now$1,
-				rateSortDirection,
-				cursor: offerCursor,
-				limit: batchSize
-			});
-			if (rawOffers.length === 0) break;
-			const newCallbackIds = rawOffers.flatMap((o) => o.callbackIds).filter((id$1) => !callbackState.has(id$1));
-			await _updateCallbacksByIds(callbackState, db, newCallbackIds);
-			await _updatePositionsByKeys(positionState, db, [...new Set(newCallbackIds.map((id$1) => callbackState.get(id$1)?.positionKey).filter((k) => k !== void 0 && !positionState.has(k)))]);
-			await _updatePrices(prices, db, _collectNewOracleAddresses(rawOffers, callbackState, positionState, prices));
-			const validOffers = _computeCrossInvalidation(rawOffers, callbackState, positionState, prices);
-			let isOfferInPreviousPages = inputCursor === null;
-			const cursorRate = inputCursor ? BigInt(inputCursor.rate) : 0n;
-			for (const offer of validOffers) {
-				if (!isOfferInPreviousPages) if (rateSortDirection === "asc" ? offer.rate > cursorRate : offer.rate < cursorRate) isOfferInPreviousPages = true;
-				else if (offer.hash === inputCursor.hash) {
-					isOfferInPreviousPages = true;
-					continue;
-				} else continue;
-				book.push(offer);
-				if (book.length >= effectiveLimit) {
-					hasMoreOffers = true;
-					break;
-				}
-			}
-			offerCursor = rawNextCursor;
-			if (!offerCursor) break;
-		}
-		const lastReturnedOffer = book[book.length - 1];
-		const newTotalReturned = previouslyReturned + book.length;
+		const { offers: offers$1, hasMore } = await _getOffers(db, {
+			obligationId: obligationId$1,
+			side,
+			now: now$1,
+			rateSortDirection,
+			cursor: inputCursor,
+			limit: Math.min(requestedLimit, MAX_TOTAL_OFFERS - previouslyReturned)
+		});
+		const lastReturnedOffer = offers$1[offers$1.length - 1];
+		const newTotalReturned = previouslyReturned + offers$1.length;
 		const hasHitHardLimit = newTotalReturned >= MAX_TOTAL_OFFERS;
 		return {
-			offers: book,
-			nextCursor: book.length > 0 && lastReturnedOffer && !hasHitHardLimit && hasMoreOffers ? Cursor.encode(lastReturnedOffer, newTotalReturned, now$1, side) : null
+			offers: offers$1,
+			nextCursor: offers$1.length > 0 && lastReturnedOffer && !hasHitHardLimit && hasMore ? Cursor.encode(lastReturnedOffer, newTotalReturned, now$1, side) : null
 		};
 	};
 	return {
@@ -5088,8 +5448,8 @@ function create$8(config) {
 		getOffers: getOffers$1
 	};
 }
-/** Get offers with their callback IDs for a given obligation. */
-async function _getOffersWithCallbackIds(db, params) {
+/** Get offers with computed takeable based on lot balance. */
+async function _getOffers(db, params) {
 	const { obligationId: obligationId$1, side, now: now$1, rateSortDirection, cursor, limit } = params;
 	const raw = await db.execute(sql`
     WITH collats AS MATERIALIZED (
@@ -5157,32 +5517,202 @@ async function _getOffersWithCallbackIds(db, params) {
       ORDER BY e.rate ${rateSortDirection === "asc" ? sql`ASC` : sql`DESC`}, e.block_number ASC, e.assets DESC, e.hash ASC
       LIMIT ${limit}
     ),
-    with_callbacks AS (
+    -- Compute sum of offsets per position
+    position_offsets AS (
       SELECT
-        p.hash, p.obligation_id, p.assets, p.rate, p.maturity, p.expiry, p.start,
-        p.nonce, p.buy, p.callback_address, p.callback_data, p.block_number,
-        p.group_chain_id, p.group_maker, p.consumed, p.chain_id, p.loan_token,
-        COALESCE(ARRAY_AGG(oc.callback_id) FILTER (WHERE oc.callback_id IS NOT NULL), '{}') AS callback_ids
+        chain_id,
+        "user",
+        contract,
+        SUM(value::numeric) AS total_offset
+      FROM ${offsets}
+      GROUP BY chain_id, "user", contract
+    ),
+    -- Compute position_consumed: sum of consumed from all groups with lots on each position (converted to lot terms)
+    position_consumed AS (
+      SELECT
+        l.chain_id,
+        l.contract,
+        l."user",
+        SUM(
+          CASE
+            WHEN wo.assets::numeric > 0
+            THEN COALESCE(g.consumed::numeric, 0) * (l.upper::numeric - l.lower::numeric) / wo.assets::numeric
+            ELSE 0
+          END
+        ) AS consumed
+      FROM ${lots} l
+      JOIN ${groups} g
+        ON g.chain_id = l.chain_id
+        AND LOWER(g.maker) = LOWER(l."user")
+        AND g."group" = l."group"
+      JOIN winners wo
+        ON wo.group_chain_id = g.chain_id
+        AND LOWER(wo.group_maker) = LOWER(g.maker)
+        AND wo.group_group = g."group"
+      GROUP BY l.chain_id, l.contract, l."user"
+    ),
+    -- Compute callback contributions with lot balance
+    callback_contributions AS (
+      SELECT
+        p.hash,
+        p.obligation_id,
+        p.assets,
+        p.rate,
+        p.maturity,
+        p.expiry,
+        p.start,
+        p.nonce,
+        p.buy,
+        p.callback_address,
+        p.callback_data,
+        p.block_number,
+        p.group_chain_id,
+        p.group_maker,
+        p.group_group,
+        p.consumed,
+        p.chain_id,
+        p.loan_token,
+        c.id AS callback_id,
+        c.position_chain_id,
+        c.position_contract,
+        c.position_user,
+        c.amount AS callback_amount,
+        pos.balance AS position_balance,
+        pos.asset AS position_asset,
+        l.lower AS lot_lower,
+        l.upper AS lot_upper,
+        -- Compute lot_balance: min(position_balance + offset + position_consumed - lot.lower, lot.size - lot_consumed)
+        -- lot_consumed is converted from loan token to lot terms: consumed * lot_size / assets
+        GREATEST(0, LEAST(
+          COALESCE(pos.balance::numeric, 0) + COALESCE(pos_offsets.total_offset, 0) + COALESCE(pc.consumed, 0) - COALESCE(l.lower::numeric, 0),
+          (COALESCE(l.upper::numeric, 0) - COALESCE(l.lower::numeric, 0)) -
+            CASE
+              WHEN p.assets::numeric > 0
+              THEN COALESCE(p.consumed::numeric, 0) * (COALESCE(l.upper::numeric, 0) - COALESCE(l.lower::numeric, 0)) / p.assets::numeric
+              ELSE 0
+            END
+        )) AS lot_balance
       FROM paged p
       LEFT JOIN ${offersCallbacks} oc ON oc.offer_hash = p.hash
-      GROUP BY p.hash, p.obligation_id, p.assets, p.rate, p.maturity, p.expiry, p.start,
-               p.nonce, p.buy, p.callback_address, p.callback_data, p.block_number,
-               p.group_chain_id, p.group_maker, p.consumed, p.chain_id, p.loan_token
+      LEFT JOIN ${callbacks} c ON c.id = oc.callback_id
+      LEFT JOIN ${lots} l
+        ON l.chain_id = c.position_chain_id
+        AND LOWER(l.contract) = LOWER(c.position_contract)
+        AND LOWER(l."user") = LOWER(c.position_user)
+        AND l."group" = p.group_group
+      LEFT JOIN ${positions} pos
+        ON pos.chain_id = c.position_chain_id
+        AND LOWER(pos.contract) = LOWER(c.position_contract)
+        AND LOWER(pos."user") = LOWER(c.position_user)
+      LEFT JOIN position_offsets pos_offsets
+        ON pos_offsets.chain_id = c.position_chain_id
+        AND LOWER(pos_offsets.contract) = LOWER(c.position_contract)
+        AND LOWER(pos_offsets."user") = LOWER(c.position_user)
+      LEFT JOIN position_consumed pc
+        ON pc.chain_id = c.position_chain_id
+        AND LOWER(pc.contract) = LOWER(c.position_contract)
+        AND LOWER(pc."user") = LOWER(c.position_user)
+    ),
+    -- Compute contribution per callback in loan terms (with oracle price via LEFT JOIN)
+    callback_loan_contribution AS (
+      SELECT
+        cc.*,
+        CASE
+          -- No lot exists: contribution is 0
+          WHEN cc.lot_lower IS NULL THEN 0
+          -- Loan token position: use lot_balance directly, apply callback limit
+          WHEN LOWER(cc.position_asset) = LOWER(cc.loan_token) THEN
+            LEAST(
+              cc.lot_balance,
+              COALESCE(cc.callback_amount::numeric, cc.lot_balance)
+            )
+          -- Collateral position: convert to loan using (amount * price / 10^36) * lltv / 10^18
+          ELSE
+            (
+              LEAST(
+                cc.lot_balance,
+                COALESCE(cc.callback_amount::numeric, cc.lot_balance)
+              ) * COALESCE(collat_oracle.price::numeric, 0) / 1e36
+            ) * COALESCE(collat_info.lltv::numeric, 0) / 1e18
+        END AS contribution_in_loan
+      FROM callback_contributions cc
+      LEFT JOIN ${obligationCollateralsV2} collat_info
+        ON collat_info.obligation_id = cc.obligation_id
+        AND LOWER(collat_info.asset) = LOWER(cc.position_asset)
+      LEFT JOIN ${oracles} collat_oracle
+        ON collat_oracle.chain_id = collat_info.oracle_chain_id
+        AND LOWER(collat_oracle.address) = LOWER(collat_info.oracle_address)
+    ),
+    -- Aggregate contributions per offer, deduplicating by position using DISTINCT ON
+    offer_contributions AS (
+      SELECT
+        hash,
+        obligation_id,
+        assets,
+        rate,
+        maturity,
+        expiry,
+        start,
+        nonce,
+        buy,
+        callback_address,
+        callback_data,
+        block_number,
+        group_chain_id,
+        group_maker,
+        consumed,
+        chain_id,
+        loan_token,
+        SUM(contribution_in_loan) AS total_available
+      FROM (
+        -- Take max contribution per position using DISTINCT ON (idiomatic PostgreSQL)
+        SELECT DISTINCT ON (clc.hash, clc.position_chain_id, clc.position_contract, clc.position_user)
+          clc.*
+        FROM callback_loan_contribution clc
+        WHERE clc.callback_id IS NOT NULL
+        ORDER BY clc.hash, clc.position_chain_id, clc.position_contract, clc.position_user, clc.contribution_in_loan DESC
+      ) deduped
+      GROUP BY hash, obligation_id, assets, rate, maturity, expiry, start, nonce, buy,
+               callback_address, callback_data, block_number, group_chain_id, group_maker,
+               consumed, chain_id, loan_token
     )
+    -- Final SELECT with inline takeable computation
     SELECT
-      wc.hash, wc.group_maker, wc.assets, wc.consumed, wc.rate, wc.maturity, wc.expiry, wc.start,
-      wc.nonce, wc.buy, wc.chain_id, wc.loan_token, wc.callback_address, wc.callback_data,
-      wc.block_number, wc.callback_ids, c.collaterals
-    FROM with_callbacks wc
-    LEFT JOIN collats c ON c.obligation_id = wc.obligation_id
+      oc.hash,
+      oc.group_maker,
+      oc.assets,
+      oc.consumed,
+      oc.rate,
+      oc.maturity,
+      oc.expiry,
+      oc.start,
+      oc.nonce,
+      oc.buy,
+      oc.chain_id,
+      oc.loan_token,
+      oc.callback_address,
+      oc.callback_data,
+      oc.block_number,
+      -- takeable = min(assets - consumed, total_available)
+      GREATEST(0, LEAST(
+        oc.assets::numeric - oc.consumed::numeric,
+        COALESCE(oc.total_available, 0)
+      )) AS takeable,
+      c.collaterals
+    FROM offer_contributions oc
+    LEFT JOIN collats c ON c.obligation_id = oc.obligation_id
+    WHERE GREATEST(0, LEAST(
+      oc.assets::numeric - oc.consumed::numeric,
+      COALESCE(oc.total_available, 0)
+    )) > 0
     ORDER BY
-      wc.rate ${rateSortDirection === "asc" ? sql`ASC` : sql`DESC`},
-      wc.block_number ASC,
-      wc.assets DESC,
-      wc.hash ASC;
+      oc.rate ${rateSortDirection === "asc" ? sql`ASC` : sql`DESC`},
+      oc.block_number ASC,
+      oc.assets DESC,
+      oc.hash ASC;
   `);
-	const offers$1 = raw.rows.map((row) => ({
-		...from$9({
+	return {
+		offers: raw.rows.map((row) => from$9({
 			offering: row.group_maker,
 			assets: BigInt(row.assets),
 			rate: BigInt(row.rate),
@@ -5204,165 +5734,12 @@ async function _getOffersWithCallbackIds(db, params) {
 				gasLimit: 0n
 			},
 			consumed: BigInt(row.consumed),
-			takeable: 0n,
+			takeable: BigInt(row.takeable.split(".")[0] ?? "0"),
 			blockNumber: row.block_number
-		}),
-		callbackIds: row.callback_ids ?? []
-	}));
-	let nextCursor = null;
-	if (raw.rows.length === limit) {
-		const last = raw.rows[raw.rows.length - 1];
-		nextCursor = {
-			rate: last.rate,
-			blockNumber: last.block_number,
-			assets: last.assets,
-			hash: last.hash
-		};
-	}
-	return {
-		offers: offers$1,
-		nextCursor
+		})),
+		hasMore: raw.rows.length === limit
 	};
 }
-/** Get callbacks by their IDs. */
-async function _updateCallbacksByIds(state, db, ids) {
-	if (ids.length === 0) return;
-	const raw = await db.execute(sql`
-    SELECT c.id, c.position_chain_id, c.position_contract, c.position_user, c.amount
-    FROM ${callbacks} c
-    WHERE c.id IN (${sql.join(ids.map((id$1) => sql`${id$1}`), sql`, `)})
-  `);
-	for (const row of raw.rows) if (!state.has(row.id)) state.set(row.id, {
-		positionKey: _buildPositionKey(row.position_chain_id, row.position_contract, row.position_user),
-		amount: row.amount != null ? BigInt(row.amount) : null
-	});
-}
-/** Get positions by their composite keys. */
-async function _updatePositionsByKeys(state, db, keys) {
-	if (keys.length === 0) return;
-	const parsedKeys = keys.map((key) => {
-		const parts = key.split(":");
-		return {
-			chainId: BigInt(parts[0]),
-			contract: parts[1],
-			user: parts[2]
-		};
-	});
-	const raw = await db.execute(sql`
-    SELECT p.chain_id, p.contract, p."user", p.balance, p.asset
-    FROM ${positions} p
-    WHERE (p.chain_id, LOWER(p.contract), LOWER(p."user")) IN (
-      ${sql.join(parsedKeys.map((k) => sql`(${k.chainId}, ${k.contract.toLowerCase()}, ${k.user.toLowerCase()})`), sql`, `)}
-    )
-  `);
-	for (const row of raw.rows) {
-		const key = _buildPositionKey(row.chain_id, row.contract, row.user);
-		if (!state.has(key)) state.set(key, {
-			balance: row.balance ? BigInt(row.balance) : 0n,
-			remaining: row.balance ? BigInt(row.balance) : 0n,
-			asset: row.asset ?? "0x0000000000000000000000000000000000000000"
-		});
-	}
-}
-/** Get oracle prices by chain_id and address. */
-async function _updatePrices(state, db, oracles$1) {
-	if (oracles$1.length === 0) return;
-	const raw = await db.execute(sql`
-    SELECT o.chain_id, o.address, o.price
-    FROM ${oracles} o
-    WHERE (o.chain_id, LOWER(o.address)) IN (${sql.join(oracles$1.map((o) => sql`(${o.chainId}, ${o.address.toLowerCase()})`), sql`, `)})
-  `);
-	for (const row of raw.rows) {
-		const key = `${row.chain_id}:${row.address.toLowerCase()}`;
-		if (!state.has(key)) state.set(key, row.price ? BigInt(row.price) : 0n);
-	}
-}
-/** Build a composite position key from its components. */
-function _buildPositionKey(chainId, contract, user) {
-	return `${chainId}:${contract.toLowerCase()}:${user.toLowerCase()}`;
-}
-/** Collect oracle addresses that need to be Geted for collateral positions. */
-function _collectNewOracleAddresses(offers$1, callbackState, positionState, prices) {
-	const seen = /* @__PURE__ */ new Set();
-	const result = [];
-	for (const offer of offers$1) for (const callbackId of offer.callbackIds) {
-		const callback$1 = callbackState.get(callbackId);
-		if (!callback$1) continue;
-		const position = positionState.get(callback$1.positionKey);
-		if (!position) continue;
-		if (position.asset.toLowerCase() === offer.loanToken.toLowerCase()) continue;
-		const collateral = offer.collaterals.find((c) => c.asset.toLowerCase() === position.asset.toLowerCase());
-		if (collateral) {
-			const key = `${offer.chainId}:${collateral.oracle.toLowerCase()}`;
-			if (!prices.has(key) && !seen.has(key)) {
-				seen.add(key);
-				result.push({
-					chainId: offer.chainId,
-					address: collateral.oracle.toLowerCase()
-				});
-			}
-		}
-	}
-	return result;
-}
-/**
-* Compute cross-invalidation for a batch of offers.
-* Deducts consumed liquidity from shared positions and returns offers with takeable amounts.
-*/
-function _computeCrossInvalidation(offers$1, callbackState, positionState, prices) {
-	const result = [];
-	for (const offer of offers$1) {
-		const contributions = /* @__PURE__ */ new Map();
-		for (const callbackId of offer.callbackIds) {
-			const callback$1 = callbackState.get(callbackId);
-			if (!callback$1) continue;
-			const position = positionState.get(callback$1.positionKey);
-			if (!position) continue;
-			let conversion;
-			if (position.asset.toLowerCase() === offer.loanToken.toLowerCase()) conversion = null;
-			else {
-				const collateral = offer.collaterals.find((c) => c.asset.toLowerCase() === position.asset.toLowerCase());
-				if (!collateral) conversion = {
-					price: 0n,
-					lltv: 0n
-				};
-				else {
-					const key = `${offer.chainId}:${collateral.oracle.toLowerCase()}`;
-					conversion = {
-						price: prices.get(key) ?? 0n,
-						lltv: collateral.lltv
-					};
-				}
-			}
-			const availableFromPosition = conversion === null ? position.remaining : Conversion.collateralToLoan(position.remaining, conversion);
-			const callbackLimitInLoanTerms = conversion === null || callback$1.amount === null ? callback$1.amount : Conversion.collateralToLoan(callback$1.amount, conversion);
-			const callbackAvailable = callbackLimitInLoanTerms === null ? availableFromPosition : min(availableFromPosition, callbackLimitInLoanTerms);
-			const existing = contributions.get(callback$1.positionKey);
-			if (existing) existing.available = min(availableFromPosition, max(existing.available, callbackAvailable));
-			else contributions.set(callback$1.positionKey, {
-				available: callbackAvailable,
-				conversion
-			});
-		}
-		let totalAvailable = 0n;
-		for (const [, contrib] of contributions) totalAvailable += contrib.available;
-		const takeable = min(offer.assets - offer.consumed, totalAvailable);
-		if (takeable <= 0n) continue;
-		for (const [key, contrib] of contributions) {
-			const position = positionState.get(key);
-			const proportionalTakeable = totalAvailable > 0n ? contrib.available * takeable / totalAvailable : 0n;
-			const toDeduct = contrib.conversion === null ? proportionalTakeable : Conversion.loanToCollateral(proportionalTakeable, contrib.conversion);
-			position.remaining = position.remaining - toDeduct;
-			if (position.remaining < 0n) position.remaining = 0n;
-		}
-		const { callbackIds: _, ...cleanOffer } = offer;
-		result.push(from$9({
-			...cleanOffer,
-			takeable
-		}));
-	}
-	return result;
-}
 let Cursor;
 (function(_Cursor) {
 	function encode(offer, totalReturned, now$1, side) {
@@ -5427,7 +5804,7 @@ let LevelCursor;
 //#endregion
 //#region src/database/domains/Chains.ts
 /** Postgres implementation. */
-const create$7 = (config) => {
+const create$10 = (config) => {
 	const db = config.db;
 	const logger = getLogger();
 	return {
@@ -5483,7 +5860,7 @@ const create$7 = (config) => {
 //#endregion
 //#region src/database/domains/Collectors.ts
 /** Postgres implementation. */
-const create$6 = (config) => {
+const create$9 = (config) => {
 	const db = config.db;
 	const logger = getLogger();
 	return {
@@ -5576,7 +5953,7 @@ const DEFAULT_BATCH_SIZE = 4e3;
 
 //#endregion
 //#region src/database/domains/Consumed.ts
-function create$5(db) {
+function create$8(db) {
 	return {
 		create: async (events) => {
 			if (events.length === 0) return;
@@ -5617,10 +5994,55 @@ function create$5(db) {
 	};
 }
 
+//#endregion
+//#region src/database/domains/Lots.ts
+function create$7(db) {
+	return {
+		get: async (parameters) => {
+			const { chainId, user, contract, group } = parameters ?? {};
+			const conditions = [];
+			if (chainId !== void 0) conditions.push(eq(lots.chainId, chainId));
+			if (user !== void 0) conditions.push(eq(lots.user, user.toLowerCase()));
+			if (contract !== void 0) conditions.push(eq(lots.contract, contract.toLowerCase()));
+			if (group !== void 0) conditions.push(eq(lots.group, group));
+			return (await db.select().from(lots).where(conditions.length > 0 ? and(...conditions) : void 0)).map((row) => ({
+				chainId: row.chainId,
+				user: row.user,
+				contract: row.contract,
+				group: row.group,
+				lower: BigInt(row.lower),
+				upper: BigInt(row.upper)
+			}));
+		},
+		create: async (parameters) => {
+			if (parameters.length === 0) return;
+			const lotsByPositionGroup = /* @__PURE__ */ new Map();
+			for (const offer of parameters) {
+				const key = `${offer.positionChainId}-${offer.positionContract}-${offer.positionUser}-${offer.group}`.toLowerCase();
+				const existing = lotsByPositionGroup.get(key);
+				if (!existing || offer.size > existing.size) lotsByPositionGroup.set(key, offer);
+			}
+			for (const offer of lotsByPositionGroup.values()) if ((await db.select().from(lots).where(and(eq(lots.chainId, offer.positionChainId), eq(lots.contract, offer.positionContract.toLowerCase()), eq(lots.user, offer.positionUser.toLowerCase()), eq(lots.group, offer.group))).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())));
+				const newLower = BigInt(maxUpperResult[0]?.maxUpper ?? "0");
+				const newUpper = newLower + offer.size;
+				await db.insert(lots).values({
+					chainId: offer.positionChainId,
+					user: offer.positionUser.toLowerCase(),
+					contract: offer.positionContract.toLowerCase(),
+					group: offer.group,
+					lower: newLower.toString(),
+					upper: newUpper.toString()
+				});
+			}
+		}
+	};
+}
+
 //#endregion
 //#region src/database/domains/Offers.ts
 const DEFAULT_LIMIT$2 = 100;
-function create$4(config) {
+function create$6(config) {
 	const db = config.db;
 	return {
 		create: async (offers$1) => {
@@ -5779,6 +6201,22 @@ function create$4(config) {
 					amount: callback$1.amount
 				})));
 				for (const batch$2 of batch$1(callbacksRows, DEFAULT_BATCH_SIZE)) await dbTx.insert(callbacks).values(batch$2).onConflictDoNothing();
+				const lotInfos = [];
+				for (const [offerHash, callbacks$1] of offersCallbacksMap.entries()) {
+					const offer = inserted.find((o) => o.hash === offerHash);
+					if (!offer) continue;
+					for (const callback$1 of callbacks$1) {
+						const isLoanPosition = obligationsMap.get(offer.obligationId)?.loanToken.toLowerCase() === callback$1.asset?.toLowerCase();
+						lotInfos.push({
+							positionChainId: callback$1.chainId,
+							positionContract: callback$1.contract,
+							positionUser: callback$1.user,
+							group: offer.group,
+							size: isLoanPosition ? BigInt(offer.assets) : BigInt(callback$1.amount)
+						});
+					}
+				}
+				if (lotInfos.length > 0) await dbTx.lots.create(lotInfos);
 				obligationsMap.clear();
 				collateralsMap.clear();
 				oraclesMap.clear();
@@ -5961,9 +6399,29 @@ function create$4(config) {
 	};
 }
 
+//#endregion
+//#region src/database/domains/Offsets.ts
+function create$5(db) {
+	return { get: async (parameters) => {
+		const { chainId, user, contract, group } = parameters ?? {};
+		const conditions = [];
+		if (chainId !== void 0) conditions.push(eq(offsets.chainId, chainId));
+		if (user !== void 0) conditions.push(eq(offsets.user, user.toLowerCase()));
+		if (contract !== void 0) conditions.push(eq(offsets.contract, contract.toLowerCase()));
+		if (group !== void 0) conditions.push(eq(offsets.group, group));
+		return (await db.select().from(offsets).where(conditions.length > 0 ? and(...conditions) : void 0)).map((row) => ({
+			chainId: row.chainId,
+			user: row.user,
+			contract: row.contract,
+			group: row.group,
+			value: BigInt(row.value)
+		}));
+	} };
+}
+
 //#endregion
 //#region src/database/domains/Oracles.ts
-function create$3(db) {
+function create$4(db) {
 	return {
 		get: async ({ chainId }) => {
 			return (await db.select({
@@ -6003,7 +6461,7 @@ function create$3(db) {
 //#endregion
 //#region src/database/domains/Positions.ts
 const DEFAULT_LIMIT$1 = 100;
-const create$2 = (db) => {
+const create$3 = (db) => {
 	return {
 		upsert: async (positions$1) => {
 			const positionsMap = /* @__PURE__ */ new Map();
@@ -6119,7 +6577,7 @@ const create$2 = (db) => {
 
 //#endregion
 //#region src/database/domains/Transfers.ts
-const create$1 = (db) => ({ create: async (transfers$1) => {
+const create$2 = (db) => ({ create: async (transfers$1) => {
 	if (transfers$1.length === 0) return 0;
 	return await db.transaction(async (dbTx) => {
 		let totalInserted = 0;
@@ -6216,6 +6674,91 @@ const create$1 = (db) => ({ create: async (transfers$1) => {
 	});
 } });
 
+//#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$1(config) {
+	const db = config.db;
+	return {
+		create: async (trees$1) => {
+			if (trees$1.length === 0) return [];
+			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()`
+						}
+					});
+					await dbTx.offers.create(tree.offers);
+					const pathRows = proofs(tree).map((proof) => ({
+						offerHash: proof.offer.hash.toLowerCase(),
+						treeRoot: root,
+						proofNodes: concatenateProofs(proof.path)
+					}));
+					for (const batch$2 of batch$1(pathRows, DEFAULT_BATCH_SIZE)) await dbTx.insert(merklePaths).values(batch$2).onConflictDoUpdate({
+						target: [merklePaths.offerHash],
+						set: {
+							treeRoot: sql`excluded.tree_root`,
+							proofNodes: sql`excluded.proof_nodes`,
+							createdAt: sql`NOW()`
+						}
+					});
+				}
+				return roots;
+			});
+		},
+		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$1) {
+	if (proofs$1.length === 0) return "0x";
+	return `0x${proofs$1.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$1 = concatenated.slice(2);
+	const proofs$1 = [];
+	for (let i = 0; i < hex$1.length; i += 64) proofs$1.push(`0x${hex$1.slice(i, i + 64)}`);
+	return proofs$1;
+}
+
 //#endregion
 //#region src/database/domains/Validations.ts
 const DEFAULT_LIMIT = 100;
@@ -6280,15 +6823,18 @@ function create(db) {
 //#region src/database/Database.ts
 function createDomains(core) {
 	return {
-		book: create$8({ db: core }),
-		collectors: create$6({ db: core }),
-		offers: create$4({ db: core }),
-		chains: create$7({ db: core }),
-		consumed: create$5(core),
-		oracles: create$3(core),
+		book: create$11({ db: core }),
+		collectors: create$9({ db: core }),
+		offers: create$6({ db: core }),
+		chains: create$10({ db: core }),
+		consumed: create$8(core),
+		lots: create$7(core),
+		offsets: create$5(core),
+		oracles: create$4(core),
+		trees: create$1({ db: core }),
 		validations: create(core),
-		positions: create$2(core),
-		transfers: create$1(core)
+		positions: create$3(core),
+		transfers: create$2(core)
 	};
 }
 const AUGMENT_CACHE = /* @__PURE__ */ new WeakMap();
@@ -6323,10 +6869,22 @@ function augmentWithDomains(base$1) {
 			value: dms.consumed,
 			enumerable: true
 		},
+		lots: {
+			value: dms.lots,
+			enumerable: true
+		},
+		offsets: {
+			value: dms.offsets,
+			enumerable: true
+		},
 		oracles: {
 			value: dms.oracles,
 			enumerable: true
 		},
+		trees: {
+			value: dms.trees,
+			enumerable: true
+		},
 		validations: {
 			value: dms.validations,
 			enumerable: true
@@ -6343,6 +6901,7 @@ function augmentWithDomains(base$1) {
 	AUGMENT_CACHE.set(base$1, wrapped);
 	return wrapped;
 }
+let cachedInMemoryDatabase;
 /**
 * Connect to the database.
 * @notice If no connection string is provided, an in-process PGLite database is created.
@@ -6365,15 +6924,17 @@ function connect(connectionString) {
 			clean: async () => await clean(driver$1)
 		});
 	}
+	if (cachedInMemoryDatabase) return cachedInMemoryDatabase;
 	const pool = new PGlite();
 	const driver = drizzle$1(pool, { schema: schema_exports });
 	const core = augmentWithDomains(driver);
-	return Object.assign(core, {
+	cachedInMemoryDatabase = Object.assign(core, {
 		name: "pglite",
 		pool,
 		applyMigrations: applyMigrations("pglite", driver),
 		clean: async () => await clean(driver)
 	});
+	return cachedInMemoryDatabase;
 }
 const MIGRATED_DRIVERS = /* @__PURE__ */ new WeakSet();
 function applyMigrations(kind, driver) {
@@ -6577,6 +7138,35 @@ async function postMigrate(driver) {
     REFERENCING OLD TABLE AS deleted_rows
     FOR EACH STATEMENT
     EXECUTE FUNCTION cleanup_orphan_positions();
+    `);
+		await driver.execute(`
+    CREATE OR REPLACE FUNCTION cleanup_orphan_groups()
+    RETURNS TRIGGER AS $$
+    BEGIN
+      DELETE FROM "${VERSION}"."groups" g
+      USING (
+        SELECT DISTINCT group_chain_id, group_maker, group_group
+        FROM deleted_rows
+      ) AS affected
+      WHERE g.chain_id = affected.group_chain_id
+        AND g.maker = affected.group_maker
+        AND g."group" = affected.group_group
+        AND NOT EXISTS (
+          SELECT 1 FROM "${VERSION}"."offers" o
+          WHERE o.group_chain_id = g.chain_id
+            AND o.group_maker = g.maker
+            AND o.group_group = g."group"
+        );
+      RETURN NULL;
+    END;
+    $$ LANGUAGE plpgsql;
+    `);
+		await driver.execute(`
+    CREATE OR REPLACE TRIGGER trg_cleanup_orphan_groups
+    AFTER DELETE ON "${VERSION}"."offers"
+    REFERENCING OLD TABLE AS deleted_rows
+    FOR EACH STATEMENT
+    EXECUTE FUNCTION cleanup_orphan_groups();
     `);
 		await driver.execute(`
     CREATE OR REPLACE FUNCTION cleanup_orphan_obligations_and_oracles()
@@ -6629,13 +7219,64 @@ async function postMigrate(driver) {
     REFERENCING OLD TABLE AS deleted_rows
     FOR EACH STATEMENT
     EXECUTE FUNCTION cleanup_orphan_obligations_and_oracles();
+    `);
+		await driver.execute(`
+    CREATE OR REPLACE FUNCTION create_offset_on_lot_delete()
+    RETURNS trigger
+    LANGUAGE plpgsql AS $$
+    BEGIN
+      INSERT INTO "${VERSION}"."offsets" (chain_id, "user", contract, "group", value)
+      VALUES (
+        OLD.chain_id,
+        OLD."user",
+        OLD.contract,
+        OLD."group",
+        OLD.upper::numeric - OLD.lower::numeric
+      )
+      ON CONFLICT (chain_id, "user", contract, "group") DO NOTHING;
+      RETURN OLD;
+    END;
+    $$;
+    `);
+		await driver.execute(`
+    CREATE OR REPLACE TRIGGER trg_lots_create_offset_before_delete
+    BEFORE DELETE ON "${VERSION}"."lots"
+    FOR EACH ROW
+    EXECUTE FUNCTION create_offset_on_lot_delete();
+    `);
+		await driver.execute(`
+    CREATE OR REPLACE FUNCTION delete_position_if_no_lots()
+    RETURNS trigger
+    LANGUAGE plpgsql AS $$
+    BEGIN
+      -- Check if any lots remain on this position
+      IF NOT EXISTS (
+        SELECT 1 FROM "${VERSION}"."lots" l
+        WHERE l.chain_id = OLD.chain_id
+          AND l.contract = OLD.contract
+          AND l."user" = OLD."user"
+      ) THEN
+        -- No lots remain, delete the position (cascades to offsets)
+        DELETE FROM "${VERSION}"."positions" p
+        WHERE p.chain_id = OLD.chain_id
+          AND p.contract = OLD.contract
+          AND p."user" = OLD."user";
+      END IF;
+      RETURN NULL;
+    END;
+    $$;
+    `);
+		await driver.execute(`
+    CREATE OR REPLACE TRIGGER trg_lots_delete_position_if_empty
+    AFTER DELETE ON "${VERSION}"."lots"
+    FOR EACH ROW
+    EXECUTE FUNCTION delete_position_if_no_lots();
     `);
 	});
 }
 
 //#endregion
 //#region src/cli/commands/RouterCmd.ts
-init_esm_shims();
 dotenv.config();
 var RouterCmd = class RouterCmd extends Command {
 	constructor(name$1) {
@@ -6721,7 +7362,7 @@ mockCmd.description("Start Router mock.").addOption(new Option("--seed <n>", "Se
 			file: opts.file
 		});
 	}
-	const gatekeeper = create$9({ rules: morphoRules([client.chain]) });
+	const gatekeeper = create$12({ rules: morphoRules([client.chain]) });
 	from({
 		db,
 		gatekeeper,
@@ -6766,7 +7407,7 @@ startCmd.description("Start Router services.").addOption(new Option("--block-win
 	await runWithLogger(logger, async () => {
 		const stops = [];
 		const selectedServices = new Set(opts.services);
-		const gatekeeper = create$9({ rules: morphoRules([client.chain]) });
+		const gatekeeper = create$12({ rules: morphoRules([client.chain]) });
 		if (selectedServices.has("indexer")) {
 			const indexer = from$1({
 				client,