@morpho-dev/router 0.2.1 → 0.3.0

package/dist/index.node.mjs

@@ -1,7 +1,7 @@
 import { t as __export } from "./chunk-jass6xSI.mjs";
 import { getBlock, getBlockNumber, getLogs, multicall } from "viem/actions";
 import { AsyncLocalStorage } from "node:async_hooks";
-import { bytesToHex, decodeAbiParameters, encodeAbiParameters, erc20Abi, getAddress, hashTypedData, hexToBytes, isAddress, isHex, keccak256, maxUint256, parseAbi, parseEventLogs, publicActions, stringify, zeroAddress } from "viem";
+import { bytesToHex, decodeAbiParameters, encodeAbiParameters, erc20Abi, getAddress, hashMessage, hashTypedData, hexToBytes, isAddress, isHex, keccak256, maxUint256, parseAbi, parseEventLogs, publicActions, recoverAddress, stringify, zeroAddress } from "viem";
 import { SpanStatusCode, trace } from "@opentelemetry/api";
 import "@opentelemetry/exporter-trace-otlp-proto";
 import "@opentelemetry/id-generator-aws-xray";
@@ -13,7 +13,6 @@ import "@opentelemetry/resources";
 import "@opentelemetry/sdk-trace-node";
 import "@opentelemetry/semantic-conventions";
 import { anvil, base, mainnet } from "viem/chains";
-import { generatePrivateKey, privateKeyToAccount } from "viem/accounts";
 import * as z$1 from "zod";
 import { StandardMerkleTree } from "@openzeppelin/merkle-tree";
 import { gzip, ungzip } from "pako";
@@ -408,6 +407,96 @@ function poll(fn, { interval }) {
 	return unwatch;
 }
 
+//#endregion
+//#region src/utils/Random.ts
+var Random_exports = /* @__PURE__ */ __export({
+	address: () => address,
+	bool: () => bool,
+	bytes: () => bytes,
+	float: () => float,
+	hex: () => hex,
+	int: () => int,
+	seed: () => seed,
+	withSeed: () => withSeed
+});
+let currentRng = Math.random;
+const FNV_OFFSET_BASIS = 2166136261;
+const FNV_PRIME = 16777619;
+const hashSeed = (seed$1) => {
+	let hash$1 = FNV_OFFSET_BASIS;
+	for (let i = 0; i < seed$1.length; i += 1) {
+		hash$1 ^= seed$1.charCodeAt(i);
+		hash$1 = Math.imul(hash$1, FNV_PRIME);
+	}
+	return hash$1 >>> 0;
+};
+const createSeededRng = (seed$1) => {
+	let state = hashSeed(seed$1);
+	return () => {
+		state += 1831565813;
+		let t = Math.imul(state ^ state >>> 15, state | 1);
+		t ^= t + Math.imul(t ^ t >>> 7, t | 61);
+		return ((t ^ t >>> 14) >>> 0) / 4294967296;
+	};
+};
+/**
+* Runs a function with a deterministic RNG derived from the given seed.
+*/
+function withSeed(seed$1, fn) {
+	const previous = currentRng;
+	currentRng = createSeededRng(seed$1);
+	try {
+		return fn();
+	} finally {
+		currentRng = previous;
+	}
+}
+/**
+* Seeds the global RNG for deterministic test runs.
+*/
+function seed(seed$1) {
+	currentRng = createSeededRng(seed$1);
+}
+/**
+* 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/time.ts
 var time_exports = /* @__PURE__ */ __export({
@@ -425,6 +514,7 @@ function max() {
 //#region src/utils/index.ts
 var utils_exports = /* @__PURE__ */ __export({
 	BaseError: () => BaseError,
+	Random: () => Random_exports,
 	ReorgError: () => ReorgError,
 	Time: () => time_exports,
 	batch: () => batch$1,
@@ -442,7 +532,7 @@ var utils_exports = /* @__PURE__ */ __export({
 
 //#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;
@@ -691,8 +781,8 @@ const names = [
 	"positions",
 	"prices"
 ];
-function create$13({ name, collect, client, db, options }) {
-	const admin = create$14({
+function create$16({ name, collect, client, db, options }) {
+	const admin = create$17({
 		client,
 		db,
 		options
@@ -742,7 +832,10 @@ function create$13({ name, 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({
@@ -954,8 +1047,12 @@ function decode$3(type, data) {
 }
 function encode$3(type, data) {
 	switch (type) {
-		case CallbackType.BuyVaultV1Callback: return encodeBuyVaultV1Callback(data);
-		case CallbackType.SellERC20Callback: return encodeSellERC20Callback(data);
+		case CallbackType.BuyVaultV1Callback:
+			if (!("vaults" in data)) throw new Error("Invalid callback data");
+			return encodeBuyVaultV1Callback(data);
+		case CallbackType.SellERC20Callback:
+			if (!("collaterals" in data)) throw new Error("Invalid callback data");
+			return encodeSellERC20Callback(data);
 		default: throw new Error("Invalid callback type");
 	}
 }
@@ -1152,22 +1249,22 @@ const DEFAULT_BATCH_SIZE$2 = 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$2, blockWindow = DEFAULT_BLOCK_WINDOW } = {} } = parameters;
+	const { client, contractAddress, event, blockNumberGte, blockNumberLte, order = "desc", options: { maxBatchSize = DEFAULT_BATCH_SIZE$2, 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$1(BigInt(blockNumberGte || toBlock - BigInt(blockWindow)), 0n);
-	if (order$1 === "asc") toBlock = min(toBlock, fromBlock + BigInt(blockWindow));
-	if (order$1 === "desc") fromBlock = max$1(fromBlock, toBlock - BigInt(blockWindow));
+	if (order === "asc") fromBlock = min(BigInt(blockNumberGte), latestBlock);
+	if (order === "desc") fromBlock = max$1(BigInt(blockNumberGte || toBlock - BigInt(blockWindow)), 0n);
+	if (order === "asc") toBlock = min(toBlock, fromBlock + BigInt(blockWindow));
+	if (order === "desc") fromBlock = max$1(fromBlock, toBlock - BigInt(blockWindow));
 	if (fromBlock > toBlock) throw new InvalidBlockRangeError(fromBlock, toBlock);
 	let streaming = true;
 	while (streaming) {
@@ -1177,29 +1274,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$1(fromBlock - 1n, lowerBound);
 			const nextFromBlock = max$1(fromBlock - BigInt(blockWindow) - 1n, lowerBound);
@@ -1209,7 +1306,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 {
@@ -1358,8 +1455,8 @@ const from$15 = (parameters) => {
 */
 function random$3() {
 	return from$15({
-		asset: privateKeyToAccount(generatePrivateKey()).address,
-		oracle: privateKeyToAccount(generatePrivateKey()).address,
+		asset: address(),
+		oracle: address(),
 		lltv: .965
 	});
 }
@@ -1774,12 +1871,8 @@ function id(obligation) {
 function random$2() {
 	return from$13({
 		chainId: 1,
-		loanToken: privateKeyToAccount(generatePrivateKey()).address,
-		collaterals: [from$15({
-			asset: privateKeyToAccount(generatePrivateKey()).address,
-			oracle: privateKeyToAccount(generatePrivateKey()).address,
-			lltv: .965
-		})],
+		loanToken: address(),
+		collaterals: [random$3()],
 		maturity: from$14("end_of_next_quarter")
 	});
 }
@@ -1799,101 +1892,249 @@ var CollateralsAreNotSortedError = class extends BaseError {
 //#endregion
 //#region src/core/Tree.ts
 var Tree_exports = /* @__PURE__ */ __export({
+	DecodeError: () => DecodeError,
+	EncodeError: () => EncodeError,
+	TreeError: () => TreeError,
 	VERSION: () => VERSION$1,
 	decode: () => decode$2,
 	encode: () => encode$2,
-	from: () => from$12
+	encodeUnsigned: () => encodeUnsigned,
+	from: () => from$12,
+	proofs: () => proofs
 });
 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$12 = (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 byHashAsc = (a, b) => a.localeCompare(b);
-const order = (offers$1) => {
-	return offers$1.sort((a, b) => byHashAsc(a.hash, b.hash));
+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);
 };
 /**
-* Encodes an `Tree` into a Hex string with a version byte prefix and gzipped payload.
+* Generates merkle proofs for all offers in a tree.
 *
-* - Layout: `0x{vv}{zip...}` where `{vv}` is one-byte version as two hex chars.
-* - Payload is gzip(JSON.stringify([root, ...offers])) with bigint stringified.
+* 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 offer Merkle tree to encode.
-* @returns Hex string starting with `0x{vv}` followed by gzipped payload bytes.
-* @throws Error if the given `root` does not match the offers.
+* @param tree - The {@link Tree} to generate proofs for.
+* @returns Array of proofs - {@link Proof}
 */
-const encode$2 = (tree) => {
-	assertRoot(tree.root, tree.offers);
-	const offersPayload = tree.offers.map((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
-	}));
-	const compressed = gzip(JSON.stringify([tree.root, ...offersPayload]));
-	const encoded = new Uint8Array(1 + compressed.length);
-	if (VERSION$1 > 255) throw new Error(`Version overflow: ${VERSION$1}`);
-	encoded[0] = VERSION$1;
-	encoded.set(compressed, 1);
+const proofs = (tree) => {
+	return tree.offers.map((offer) => {
+		return {
+			offer,
+			path: tree.getProof([offer.hash])
+		};
+	});
+};
+const assertHex = (value, expectedBytes, name) => {
+	if (typeof value !== "string" || !isHex(value)) throw new DecodeError(`${name} is not a valid hex string`);
+	if (hexToBytes(value).length !== expectedBytes) throw new DecodeError(`${name}: 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");
+	}
+};
+/**
+* Encodes a merkle tree with signature into hex calldata for onchain broadcast.
+*
+* Layout: `0x{vv}{gzip([...offers])}{root}{signature}` where:
+* - `{vv}`: 1-byte version (currently 0x01)
+* - `{gzip([...offers])}`: gzipped JSON array of serialized offers
+* - `{root}`: 32-byte merkle root
+* - `{signature}`: 65-byte EIP-191 signature over raw root bytes
+*
+* Validates signature authenticity and root integrity before encoding.
+*
+* @example
+* ```typescript
+* const tree = Tree.from(offers);
+* const signature = await wallet.signMessage({ message: { raw: tree.root } });
+* const calldata = await Tree.encode(tree, signature);
+* await broadcast(calldata);
+* ```
+*
+* @example
+* Manual construction (for advanced users):
+* ```typescript
+* const tree = Tree.from(offers);
+* const compressed = gzip(JSON.stringify(tree.offers.map(Offer.serialize)));
+* const partial = `0x01${bytesToHex(compressed)}${tree.root.slice(2)}`;
+* const signature = await wallet.signMessage({ message: { raw: tree.root } });
+* const calldata = `${partial}${signature.slice(2)}`;
+* ```
+*
+* @param tree - Merkle tree of offers
+* @param signature - EIP-191 signature over raw root bytes
+* @returns Hex-encoded calldata ready for onchain broadcast
+* @throws {EncodeError} If signature verification fails or root mismatch
+*/
+const encode$2 = async (tree, signature) => {
+	validateTreeForEncoding(tree);
+	await verifySignatureAndRecoverAddress({
+		root: tree.root,
+		signature
+	});
+	const unsigned = encodeUnsignedBytes(tree);
+	const sigBytes = hexToBytes(signature);
+	const encoded = new Uint8Array(unsigned.length + sigBytes.length);
+	encoded.set(unsigned, 0);
+	encoded.set(sigBytes, unsigned.length);
 	return bytesToHex(encoded);
 };
-const assertRoot = (root, offers$1) => {
-	const tree = from$12(offers$1);
-	if (root !== tree.root) throw new Error(`Invalid root: expected ${tree.root}, got ${root}`);
+/**
+* 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$12(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.
 *
-* - Ensures the first byte version matches {@link VERSION}.
-* - Decompresses with gunzip, parses JSON, validates offers, and re-checks the root.
+* Validates signature before decompression for fail-fast rejection of invalid payloads.
+* Returns the tree with separately validated signature and recovered signer address.
 *
-* @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.
+* 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)
+*
+* @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$2 = async (encoded) => {
+	const bytes$1 = hexToBytes(encoded);
+	if (bytes$1.length < 98) throw new DecodeError("payload too short");
+	const version = bytes$1[0];
+	if (version !== (VERSION$1 & 255)) throw new DecodeError(`invalid version: expected ${VERSION$1}, got ${version ?? 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$12(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).
+*/
+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.
 */
-const decode$2 = (encoded) => {
-	const bytes = hexToBytes(encoded);
-	if (bytes.length < 2) throw new Error("Invalid payload: too short");
-	const version = bytes[0];
-	if (version !== (VERSION$1 & 255)) throw new Error(`Invalid version: expected ${VERSION$1}, got ${version}`);
-	const decoded = ungzip(bytes.slice(1), { to: "string" });
-	const data = JSON.parse(decoded);
-	const root = data[0];
-	const tree = from$12(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 DecodeError = class extends BaseError {
+	name = "Tree.DecodeError";
+	constructor(reason) {
+		super(`Failed to decode tree: ${reason}`);
+	}
 };
 
 //#endregion
@@ -1913,6 +2154,7 @@ var Offer_exports = /* @__PURE__ */ __export({
 	hash: () => hash,
 	obligationId: () => obligationId,
 	random: () => random$1,
+	serialize: () => serialize,
 	sign: () => sign,
 	signatureMsg: () => signatureMsg,
 	toSnakeCase: () => toSnakeCase,
@@ -1993,16 +2235,47 @@ function toSnakeCase(offer) {
 	return toSnakeCase$1(offer);
 }
 /**
+* 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$1(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$14(maturityOption);
 	const lltv = from$16(weightedChoice([
@@ -2016,7 +2289,7 @@ function random$1(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;
@@ -2027,9 +2300,9 @@ function random$1(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,
@@ -2048,29 +2321,29 @@ function random$1(config) {
 		};
 	})();
 	return from$11({
-		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$3(),
 			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;
@@ -2538,8 +2811,8 @@ function fromSnakeCase(snake) {
 function random() {
 	return from$8({
 		obligationId: id(random$2()),
-		ask: { rate: BigInt(Math.floor(Math.random() * 1e6)) },
-		bid: { rate: BigInt(Math.floor(Math.random() * 1e6)) }
+		ask: { rate: BigInt(int(1e6)) },
+		bid: { rate: BigInt(int(1e6)) }
 	});
 }
 var InvalidQuoteError = class extends BaseError {
@@ -2723,30 +2996,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$2(payload);
-				for (const offer of tree.offers) offers$1.push({
+				const { tree, signature, signer } = await decode$2(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 (_) {}
+			} catch (err) {
+				const reason = err instanceof DecodeError && err.message.includes("signature") ? "invalid_signature" : "decode_failed";
+				logger.debug({
+					msg: "Tree decode failed",
+					reason,
+					chain_id: client.chain.id,
+					err: err instanceof Error ? err.message : String(err)
+				});
+			}
 		}
 		await db.transaction(async (dbTx) => {
 			const { epoch, blockNumber: latestBlockNumber } = await dbTx.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,
@@ -2754,10 +3076,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]
 				});
@@ -3400,7 +3723,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, collect) => create$13({
+	const createCollector = (name, collect) => create$16({
 		name,
 		collect,
 		client,
@@ -3488,7 +3811,7 @@ const from$6 = (parameters) => {
 //#endregion
 //#region src/indexer/Indexer.ts
 var Indexer_exports = /* @__PURE__ */ __export({
-	create: () => create$12,
+	create: () => create$15,
 	from: () => from$5
 });
 function from$5(config) {
@@ -3503,7 +3826,7 @@ function from$5(config) {
 		retryAttempts,
 		retryDelayMs
 	});
-	return create$12({
+	return create$15({
 		db,
 		client,
 		collectors: [
@@ -3515,7 +3838,7 @@ function from$5(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`;
@@ -3572,12 +3895,12 @@ function create$12(params) {
 
 //#endregion
 //#region src/api/Health.ts
-var Health_exports = /* @__PURE__ */ __export({ create: () => create$11 });
+var Health_exports = /* @__PURE__ */ __export({ create: () => create$14 });
 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([
@@ -3724,13 +4047,16 @@ var OfferResponse_exports = /* @__PURE__ */ __export({ from: () => from$2 });
 * Creates an `OfferResponse` from an `Offer`.
 * @constructor
 * @param offer - {@link Offer}
+* @param attestation - {@link Attestation}
 * @returns The created `OfferResponse`. {@link OfferResponse}
 */
-function from$2(offer) {
-	const result = toSnakeCase$1(offer);
+function from$2(offer, attestation) {
+	const { signature: _, ...rest } = toSnakeCase$1(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
 	};
 }
 
@@ -3868,10 +4194,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",
@@ -4016,6 +4344,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,
@@ -4199,44 +4537,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",
@@ -4301,13 +4656,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({
@@ -4476,7 +4836,7 @@ 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;
 };
@@ -4488,17 +4848,23 @@ var Cursor_exports = /* @__PURE__ */ __export({
 	encode: () => encode,
 	validate: () => validate
 });
-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`);
+	].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",
@@ -4515,24 +4881,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;
 }
@@ -4648,21 +5020,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 parse(action, query) {
 	return schemas[action].parse(query);
@@ -4745,7 +5103,7 @@ async function getDocsHtml({ gatekeeper }) {
 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$1({ status: status$1 }) });
 	} catch (err) {
 		logger.error({
@@ -4760,7 +5118,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();
@@ -4783,7 +5141,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, chainId, blockNumber, updatedAt, lag, status: status$1 }) => toSnakeCase$1({
 			name,
 			chainId,
@@ -4884,8 +5242,10 @@ async function getOffers$1(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$2),
+			data: offers$1.map((offer) => from$2(offer, attestationMap.get(offer.hash.toLowerCase()))),
 			cursor: nextCursor ?? null
 		});
 	} catch (err) {
@@ -4905,56 +5265,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$2(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$1(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$12(parsedOffers);
+		const payload = encodeUnsigned(tree);
+		return success({
+			data: {
+				payload,
+				root: tree.root
+			},
+			cursor: null
+		});
 	} catch (err) {
 		logger.error({
 			err,
@@ -4964,11 +5317,6 @@ async function validateOffers(body, gatekeeper) {
 		});
 		return failure(err);
 	}
-	const orderedResults = results.filter((r) => r !== void 0);
-	return success({
-		data: orderedResults,
-		cursor: null
-	});
 }
 
 //#endregion
@@ -4990,13 +5338,13 @@ var Controllers_exports = /* @__PURE__ */ __export({
 //#region src/api/Api.ts
 function from$1(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) };
 }
 /**
@@ -5091,7 +5439,7 @@ var RouterApi_exports = /* @__PURE__ */ __export({
 	OpenApi: () => OpenApi,
 	RouterStatusResponse: () => RouterStatusResponse,
 	ValidateController: () => ValidateController,
-	create: () => create$10,
+	create: () => create$13,
 	from: () => from$1,
 	parse: () => parse,
 	safeParse: () => safeParse
@@ -5156,24 +5504,28 @@ async function getOffers(apiClient, parameters) {
 		throw new HttpGetApiFailedError(`GET request returned ${response.status}`, { details: JSON.stringify(error) });
 	}
 	const offers$1 = data?.data.map((item) => {
-		const { signature, ...rest } = item;
-		return fromSnakeCase$1({
-			...rest,
-			offering: item.offering,
-			maturity: from$14(item.maturity),
-			loan_token: item.loan_token,
-			collaterals: item.collaterals.map((collateral) => ({
-				asset: collateral.asset,
-				oracle: collateral.oracle,
-				lltv: collateral.lltv
-			})),
-			callback: {
-				...item.callback,
-				address: item.callback.address,
-				data: item.callback.data
-			},
-			...signature !== null ? { signature: item.signature } : void 0
-		});
+		const { root, proof, signature, ...rest } = item;
+		return {
+			...fromSnakeCase$1({
+				...rest,
+				offering: item.offering,
+				maturity: from$14(item.maturity),
+				loan_token: item.loan_token,
+				collaterals: item.collaterals.map((collateral) => ({
+					asset: collateral.asset,
+					oracle: collateral.oracle,
+					lltv: collateral.lltv
+				})),
+				callback: {
+					...item.callback,
+					address: item.callback.address,
+					data: item.callback.data
+				},
+				signature: signature?.toLowerCase()
+			}),
+			root: root?.toLowerCase() || void 0,
+			proof: proof?.map((p) => p.toLowerCase()) || void 0
+		};
 	}) ?? [];
 	return {
 		cursor: data?.cursor ?? null,
@@ -5267,15 +5619,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);
@@ -5293,6 +5649,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);
@@ -5455,6 +5815,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(),
@@ -5550,6 +5990,17 @@ const chains$1 = 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/drizzle/index.ts
@@ -5564,15 +6015,19 @@ var drizzle_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
 });
 
@@ -5580,7 +6035,7 @@ var drizzle_exports = /* @__PURE__ */ __export({
 //#region src/database/domains/Book.ts
 const DEFAULT_LIMIT$3 = 100;
 const MAX_TOTAL_OFFERS = 500;
-function create$9(config) {
+function create$12(config) {
 	const db = config.db;
 	const logger = getLogger();
 	const getOffers$2 = async (parameters) => {
@@ -5599,52 +6054,20 @@ function create$9(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 {
@@ -5691,8 +6114,8 @@ function create$9(config) {
 		getOffers: getOffers$2
 	};
 }
-/** 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 (
@@ -5760,32 +6183,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
+        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
-        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
+        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$11({
+	return {
+		offers: raw.rows.map((row) => from$11({
 			offering: row.group_maker,
 			assets: BigInt(row.assets),
 			rate: BigInt(row.rate),
@@ -5807,165 +6400,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$1(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$11({
-			...cleanOffer,
-			takeable
-		}));
-	}
-	return result;
-}
 let Cursor;
 (function(_Cursor) {
 	function encode$4(offer, totalReturned, now$1, side) {
@@ -6030,7 +6470,7 @@ let LevelCursor;
 //#endregion
 //#region src/database/domains/Chains.ts
 /** Postgres implementation. */
-const create$8 = (config) => {
+const create$11 = (config) => {
 	const db = config.db;
 	const logger = getLogger();
 	return {
@@ -6086,7 +6526,7 @@ const create$8 = (config) => {
 //#endregion
 //#region src/database/domains/Collectors.ts
 /** Postgres implementation. */
-const create$7 = (config) => {
+const create$10 = (config) => {
 	const db = config.db;
 	const logger = getLogger();
 	return {
@@ -6179,7 +6619,7 @@ const DEFAULT_BATCH_SIZE$1 = 4e3;
 
 //#endregion
 //#region src/database/domains/Consumed.ts
-function create$6(db) {
+function create$9(db) {
 	return {
 		create: async (events) => {
 			if (events.length === 0) return;
@@ -6220,6 +6660,51 @@ function create$6(db) {
 	};
 }
 
+//#endregion
+//#region src/database/domains/Lots.ts
+function create$8(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/gatekeeper/Gate.ts
 var Gate_exports = /* @__PURE__ */ __export({
@@ -6333,8 +6818,8 @@ function getCallback(chain, type) {
 * @param address - Callback contract address
 * @returns The callback type when found, otherwise undefined
 */
-function getCallbackType(chain, address) {
-	return configs[chain].callbacks?.find((c) => c.type !== 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 callback addresses for a given chain and callback type, if it exists.
@@ -6448,8 +6933,8 @@ const configs = {
 
 //#endregion
 //#region src/gatekeeper/Gatekeeper.ts
-var Gatekeeper_exports = /* @__PURE__ */ __export({ create: () => create$5 });
-function create$5(parameters) {
+var Gatekeeper_exports = /* @__PURE__ */ __export({ create: () => create$7 });
+function create$7(parameters) {
 	return {
 		rules: parameters.rules,
 		isAllowed: async (offers$1) => {
@@ -6467,6 +6952,7 @@ var Rules_exports = /* @__PURE__ */ __export({
 	callback: () => callback,
 	chains: () => chains,
 	maturity: () => maturity,
+	sameMaker: () => sameMaker,
 	token: () => token,
 	validity: () => validity
 });
@@ -6603,10 +7089,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({ chains: chains$3 }),
 	maturity({ maturities: [MaturityType.EndOfMonth, MaturityType.EndOfNextMonth] }),
 	callback({
@@ -6623,7 +7128,7 @@ const morphoRules = (chains$3) => [
 //#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) => {
@@ -6782,6 +7287,22 @@ function create$4(config) {
 					amount: callback$1.amount
 				})));
 				for (const batch$2 of batch$1(callbacksRows, DEFAULT_BATCH_SIZE$1)) 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();
@@ -6964,9 +7485,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({
@@ -7006,7 +7547,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();
@@ -7122,7 +7663,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;
@@ -7219,6 +7760,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$1)) 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;
@@ -7284,15 +7910,18 @@ function create(db) {
 var Database_exports = /* @__PURE__ */ __export({ connect: () => connect$1 });
 function createDomains(core) {
 	return {
-		book: create$9({ db: core }),
-		collectors: create$7({ db: core }),
-		offers: create$4({ db: core }),
-		chains: create$8({ db: core }),
-		consumed: create$6(core),
-		oracles: create$3(core),
+		book: create$12({ db: core }),
+		collectors: create$10({ db: core }),
+		offers: create$6({ db: core }),
+		chains: create$11({ db: core }),
+		consumed: create$9(core),
+		lots: create$8(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();
@@ -7327,10 +7956,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
@@ -7347,6 +7988,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.
@@ -7369,15 +8011,17 @@ function connect$1(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) {
@@ -7581,6 +8225,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()
@@ -7633,6 +8306,58 @@ 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();
     `);
 	});
 }
@@ -7664,22 +8389,24 @@ async function add(config, offers$1) {
 	const tree = from$12(offers$1.map((o) => from$11(o)));
 	const chainId = await getChainId(config.client);
 	for (const offer of tree.offers) if (chainId !== offer.chainId) throw new ChainIdMismatchError(offer.chainId, chainId);
+	const signature = await sign(tree.offers, config.client);
+	const encoded = await encode$2(tree, signature);
 	try {
 		return await config.client.sendTransaction({
 			chain: config.client.chain,
 			account: config.client.account,
 			to: config.mempoolAddress,
-			data: encode$2(tree)
+			data: encoded
 		});
 	} catch (error) {
 		throw new ViemClientError(error instanceof Error ? error.message : "Unknown error");
 	}
 }
 async function* get(config, parameters) {
-	const { loanToken, blockNumberGte, blockNumberLte, order: order$1 = "desc", options: { maxBatchSize = DEFAULT_BATCH_SIZE } = {} } = parameters || {};
+	const { loanToken, blockNumberGte, blockNumberLte, order = "desc", options: { maxBatchSize = DEFAULT_BATCH_SIZE } = {} } = parameters || {};
 	yield* streamOffers(config, {
 		loanToken,
-		order: order$1,
+		order,
 		blockNumberGte,
 		blockNumberLte,
 		options: {
@@ -7701,7 +8428,7 @@ const getChainId = async (client) => {
 	return chainId;
 };
 async function* streamOffers(config, parameters) {
-	const { loanToken, blockNumberGte, blockNumberLte, order: order$1 = "desc", options: { maxBatchSize = DEFAULT_BATCH_SIZE, blockWindow = config.blockWindow } = {} } = parameters;
+	const { loanToken, blockNumberGte, blockNumberLte, order = "desc", options: { maxBatchSize = DEFAULT_BATCH_SIZE, blockWindow = config.blockWindow } = {} } = parameters;
 	const stream = streamLogs({
 		client: config.client.extend(publicActions),
 		contractAddress: config.mempoolAddress,
@@ -7718,13 +8445,13 @@ async function* streamOffers(config, parameters) {
 		},
 		blockNumberGte,
 		blockNumberLte,
-		order: order$1,
+		order,
 		options: {
 			maxBatchSize,
 			blockWindow
 		}
 	});
-	let blockNumber = order$1 === "asc" ? blockNumberGte : blockNumberLte;
+	let blockNumber = order === "asc" ? blockNumberGte : blockNumberLte;
 	for await (const { logs, blockNumber: newBlockNumber } of stream) {
 		blockNumber = newBlockNumber;
 		if (logs.length === 0) continue;
@@ -7733,7 +8460,7 @@ async function* streamOffers(config, parameters) {
 			if (!log) continue;
 			const [payload] = decodeAbiParameters([{ type: "bytes" }], log.data);
 			try {
-				const tree = decode$2(payload);
+				const { tree } = await decode$2(payload);
 				for (const offer of tree.offers) {
 					if (loanToken && offer.loanToken.toLowerCase() !== loanToken.toLowerCase()) continue;
 					offers$1.push({