@morpho-dev/router 0.5.0 → 0.6.0

package/dist/cli.js

@@ -16,7 +16,7 @@ import os from "node:os";
 import path, { dirname, resolve } from "node:path";
 import { fileURLToPath } from "node:url";
 import { mkdir, readFile, rm, writeFile } from "node:fs/promises";
-import { bytesToHex, createPublicClient, createWalletClient, decodeAbiParameters, encodeAbiParameters, erc20Abi, getAddress, hashMessage, hashTypedData, hexToBytes, http, isAddress, isHex, keccak256, maxUint256, numberToHex, pad, parseAbi, parseEventLogs, publicActions, recoverAddress, stringify, toHex, zeroAddress } from "viem";
+import { bytesToHex, createPublicClient, createWalletClient, decodeAbiParameters, encodeAbiParameters, erc20Abi, getAddress, hashTypedData, hexToBytes, http, isAddress, isHex, keccak256, maxUint256, numberToHex, pad, parseAbi, parseEventLogs, publicActions, recoverAddress, stringify, toHex, zeroAddress } from "viem";
 import { mnemonicToAccount, privateKeyToAccount } from "viem/accounts";
 import { getBlock, getBlockNumber, getLogs, multicall } from "viem/actions";
 import { anvil, base, mainnet } from "viem/chains";
@@ -26,13 +26,13 @@ import { StandardMerkleTree } from "@openzeppelin/merkle-tree";
 import { gzip, ungzip } from "pako";
 import { serve } from "@hono/node-server";
 import { Hono } from "hono";
-import { AsyncLocalStorage } from "node:async_hooks";
+import crypto, { createHash } from "node:crypto";
 import { z as z$1 } from "zod/v4";
 import "reflect-metadata";
 import { generateDocument } from "openapi-metadata";
 import { ApiBody, ApiOperation, ApiParam, ApiProperty, ApiQuery, ApiResponse, ApiTags } from "openapi-metadata/decorators";
+import { AsyncLocalStorage } from "node:async_hooks";
 import dotenv from "dotenv";
-import crypto from "node:crypto";
 import { PGlite } from "@electric-sql/pglite";
 import { drizzle } from "drizzle-orm/node-postgres";
 import { migrate } from "drizzle-orm/node-postgres/migrator";
@@ -152,7 +152,7 @@ function startActiveSpan(tracer, name, fn) {
 //#endregion
 //#region package.json
 var name = "@morpho-dev/router";
-var version = "0.5.0";
+var version = "0.6.0";
 var description = "Router package for Morpho protocol";
 
 //#endregion
@@ -1469,20 +1469,14 @@ async function run(parameters) {
 * @param parameters - Gatekeeper parameters. {@link GatekeeperParameters}
 * @returns Gatekeeper instance. {@link Gatekeeper}
 */
-function create$17(parameters) {
+function create$20(parameters) {
 	const { rules } = parameters;
-	return {
-		isAllowed: async (offers) => {
-			return await run({
-				items: offers,
-				rules
-			});
-		},
-		getRules: async () => rules.map((rule) => ({
-			name: rule.name,
-			description: rule.description
-		}))
-	};
+	return { isAllowed: async (offers) => {
+		return await run({
+			items: offers,
+			rules
+		});
+	} };
 }
 
 //#endregion
@@ -1689,17 +1683,6 @@ function getCallbackType(chain, address) {
 	return configs[chain].callbacks?.find((c) => c.type !== Type$1.BuyWithEmptyCallback && c.addresses.includes(address?.toLowerCase()))?.type;
 }
 /**
-* Returns the callback addresses for a given chain and callback type, if it exists.
-* @param chain - Chain name for which to read the validation configuration
-* @param type - Callback type to retrieve
-* @returns The matching callback addresses or an empty array if not configured
-*/
-function getCallbackTypeAddresses(chain, type) {
-	if (type === Type$1.BuyWithEmptyCallback) return [];
-	const match = configs[chain].callbacks?.find((c) => c.type === type);
-	return match && "addresses" in match ? match.addresses : [];
-}
-/**
 * Returns the list of allowed non-empty callback addresses for a chain.
 *
 * @param chain - Chain name
@@ -1836,7 +1819,7 @@ const Oracle = [{
 * @param chains - Array of chain objects to register.
 * @returns A registry for looking up chains by ID. {@link ChainRegistry}
 */
-function create$16(chains) {
+function create$19(chains) {
 	const byId = /* @__PURE__ */ new Map();
 	for (const chain of chains) byId.set(chain.id, chain);
 	return {
@@ -2158,196 +2141,6 @@ var CollateralsAreNotSortedError = class extends BaseError {
 	}
 };
 
-//#endregion
-//#region src/core/Tree.ts
-const VERSION$1 = 1;
-const normalizeHash = (hash) => hash.toLowerCase();
-/**
-* Builds a Merkle tree from a list of offers.
-*
-* Leaves are the offer `hash` values as `bytes32` and are deterministically
-* 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) => {
-	const leaves = offers.map((offer) => [hash(offer)]);
-	const tree = StandardMerkleTree.of(leaves, ["bytes32"]);
-	const orderedOffers = orderOffers(tree, offers);
-	return Object.assign(tree, { offers: orderedOffers });
-};
-const orderOffers = (tree, offers) => {
-	const offerByHash = /* @__PURE__ */ new Map();
-	for (const offer of offers) offerByHash.set(normalizeHash(hash(offer)), offer);
-	const entries = tree.dump().values.map((value) => {
-		const hash = normalizeHash(value.value[0]);
-		const offer = offerByHash.get(hash);
-		if (!offer) throw new TreeError(`missing offer for leaf ${hash}`);
-		return {
-			offer,
-			treeIndex: value.treeIndex
-		};
-	});
-	entries.sort((a, b) => b.treeIndex - a.treeIndex);
-	return entries.map((item) => item.offer);
-};
-/**
-* Generates merkle proofs for all offers in a tree.
-*
-* Each proof allows independent verification that an offer is included in the tree
-* without requiring the full tree. Proofs are ordered by StandardMerkleTree leaf ordering.
-*
-* @param tree - The {@link Tree} to generate proofs for.
-* @returns Array of proofs - {@link Proof}
-*/
-const proofs = (tree) => {
-	return tree.offers.map((offer) => {
-		return {
-			offer,
-			path: tree.getProof([hash(offer)])
-		};
-	});
-};
-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 = hashMessage({ raw: root });
-	try {
-		return await recoverAddress({
-			hash,
-			signature
-		});
-	} catch {
-		throw new DecodeError("signature recovery failed");
-	}
-};
-/**
-* 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 hex calldata into a validated merkle tree.
-*
-* Validates signature before decompression for fail-fast rejection of invalid payloads.
-* Returns the tree with separately validated signature and recovered signer address.
-*
-* 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 = async (encoded) => {
-	const bytes = hexToBytes(encoded);
-	if (bytes.length < 98) throw new DecodeError("payload too short");
-	const version = bytes[0];
-	if (version !== (VERSION$1 & 255)) throw new DecodeError(`invalid version: expected ${VERSION$1}, got ${version ?? 0}`);
-	const signature = bytesToHex(bytes.slice(-65));
-	const root = bytesToHex(bytes.slice(-97, -65));
-	assertHex(root, 32, "root");
-	assertHex(signature, 65, "signature");
-	const signer = await verifySignatureAndRecoverAddress({
-		root,
-		signature
-	});
-	const compressed = bytes.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.
-*/
-var DecodeError = class extends BaseError {
-	name = "Tree.DecodeError";
-	constructor(reason) {
-		super(`Failed to decode tree: ${reason}`);
-	}
-};
-
 //#endregion
 //#region src/core/Offer.ts
 /** Internal symbol for caching the computed hash. */
@@ -2399,7 +2192,7 @@ const OfferSchema = () => {
 * @param input - The offer to create.
 * @returns The created offer.
 */
-function from$11(input) {
+function from$12(input) {
 	try {
 		return OfferSchema().parse(input);
 	} catch (error) {
@@ -2413,7 +2206,7 @@ function from$11(input) {
 * @returns The created offer.
 */
 function fromSnakeCase(input) {
-	return from$11(fromSnakeCase$1(input));
+	return from$12(fromSnakeCase$1(input));
 }
 /**
 * Converts an offer to a snake case object.
@@ -2507,7 +2300,7 @@ function random(config) {
 			})
 		};
 	})();
-	return from$11({
+	return from$12({
 		maker: config?.maker ?? address(),
 		assets: assetsScaled,
 		obligationUnits: config?.obligationUnits ?? 0n,
@@ -2738,7 +2531,7 @@ var InvalidOfferError = class InvalidOfferError extends BaseError {
 * @param data - The data to create the oracle from.
 * @returns The created oracle.
 */
-function from$10(data) {
+function from$11(data) {
 	return {
 		chainId: data.chainId,
 		address: data.address.toLowerCase(),
@@ -2772,7 +2565,7 @@ let Type = /* @__PURE__ */ function(Type) {
 * @param parameters - {@link from.Parameters}
 * @returns The created Position. {@link from.ReturnType}
 */
-function from$9(parameters) {
+function from$10(parameters) {
 	return {
 		chainId: parameters.chainId,
 		contract: parameters.contract.toLowerCase(),
@@ -2803,7 +2596,7 @@ const QuoteSchema = z$2.object({
 * const quote = Quote.from({ obligationId: "0x123", ask: { price: 100n }, bid: { price: 100n } });
 * ```
 */
-function from$8(parameters) {
+function from$9(parameters) {
 	try {
 		const parsedQuote = QuoteSchema.parse(parameters);
 		return {
@@ -2841,7 +2634,7 @@ const WAD = 10n ** 18n;
 * const transfer = Transfer.from({ id: "1", chainId: 1, contract: "0x123", from: "0x456", to: "0x789", value: 100n, blockNumber: 100n });
 * ```
 */
-function from$7(parameters) {
+function from$8(parameters) {
 	return {
 		id: parameters.id,
 		chainId: parameters.chainId,
@@ -2854,51 +2647,288 @@ function from$7(parameters) {
 }
 
 //#endregion
-//#region src/core/types.ts
-const BrandTypeId = Symbol.for("mempool/Brand");
-
-//#endregion
-//#region src/gatekeeper/Rules.ts
-const chains$1 = ({ chains }) => single("chain_ids", `Validates that offer chain is one of: [${chains.map((c) => c.id).join(", ")}]`, (offer) => {
-	const allowedChainIds = chains.map((c) => c.id);
-	if (!allowedChainIds.some((id) => id === offer.chainId)) return { message: `Chain ID ${offer.chainId} is not in the allowed chains (${allowedChainIds.join(", ")})` };
-});
-const maturity = ({ maturities }) => single("maturity", `Validates that offer maturity is one of: [${maturities.join(", ")}]`, (offer) => {
-	const allowedMaturities = maturities.map((m) => from$16(m));
-	if (!allowedMaturities.includes(offer.maturity)) return { message: `Maturity must be end of current month (${allowedMaturities[0]}) or end of next month (${allowedMaturities[1]}). Got: ${offer.maturity}` };
-});
-const callback = ({ callbacks, allowedAddresses }) => single("callback", `Validates callbacks: buy empty callback is ${callbacks.includes(Type$1.BuyWithEmptyCallback) ? "allowed" : "not allowed"}; sell offers must use a non-empty callback; non-empty callbacks must target one of [${allowedAddresses.map((a) => a.toLowerCase()).join(", ")}]`, (offer) => {
-	if (isEmptyCallback(offer) && offer.buy && !callbacks?.find((c) => c === Type$1.BuyWithEmptyCallback)) return { message: "Buy offers with empty callback not allowed." };
-	if (isEmptyCallback(offer) && !offer.buy) return { message: "Sell offers require a non-empty callback." };
-	if (!isEmptyCallback(offer)) {
-		if (!allowedAddresses.includes(offer.callback.address?.toLowerCase())) return { message: `Callback address ${offer.callback.address} is not allowed.` };
-	}
-});
+//#region src/core/Tree.ts
+const VERSION$1 = 1;
 /**
-* A validation rule that checks if the offer's tokens are allowed for its chain.
-* @param assetsByChainId - Allowed assets indexed by chain id.
-* @returns The issue that was found. If the offer is valid, this will be undefined.
+* EIP-712 types for signing the tree root (Root(bytes32 root)).
 */
-const token = ({ assetsByChainId }) => single("token", "Validates that offer loan token and collateral tokens are in the allowed assets list for the offer chain", (offer) => {
-	const allowedAssets = assetsByChainId[offer.chainId]?.map((asset) => asset.toLowerCase());
-	if (!allowedAssets || allowedAssets.length === 0) return { message: `No allowed assets for chain ${offer.chainId}` };
-	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" };
-});
+const signatureTypes = {
+	EIP712Domain: [{
+		name: "chainId",
+		type: "uint256"
+	}, {
+		name: "verifyingContract",
+		type: "address"
+	}],
+	Root: [{
+		name: "root",
+		type: "bytes32"
+	}]
+};
+const normalizeHash = (hash) => hash.toLowerCase();
 /**
-* A batch validation rule that ensures all offers in a tree have the same maker address.
-* Returns an issue only for the first non-conforming offer.
-* This rule is signing-agnostic; signer verification is handled at the collector level.
+* Builds a Merkle tree from a list of offers.
+*
+* Leaves are the offer `hash` values as `bytes32` and are deterministically
+* 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 sameMaker = () => batch("mixed_maker", "Validates that all offers in a batch have the same maker address", (offers) => {
-	const issues = /* @__PURE__ */ new Map();
-	if (offers.length === 0) return issues;
-	const firstMaker = offers[0].maker.toLowerCase();
-	for (let i = 1; i < offers.length; i++) {
-		const offer = offers[i];
-		if (offer.maker.toLowerCase() !== firstMaker) {
-			issues.set(i, { message: `Offer has different maker ${offer.maker} than first offer ${offers[0].maker}` });
-			return issues;
+const from$7 = (offers) => {
+	const leaves = offers.map((offer) => [hash(offer)]);
+	const tree = StandardMerkleTree.of(leaves, ["bytes32"]);
+	const orderedOffers = orderOffers(tree, offers);
+	return Object.assign(tree, { offers: orderedOffers });
+};
+const orderOffers = (tree, offers) => {
+	const offerByHash = /* @__PURE__ */ new Map();
+	for (const offer of offers) offerByHash.set(normalizeHash(hash(offer)), offer);
+	const entries = tree.dump().values.map((value) => {
+		const hash = normalizeHash(value.value[0]);
+		const offer = offerByHash.get(hash);
+		if (!offer) throw new TreeError(`missing offer for leaf ${hash}`);
+		return {
+			offer,
+			treeIndex: value.treeIndex
+		};
+	});
+	entries.sort((a, b) => b.treeIndex - a.treeIndex);
+	return entries.map((item) => item.offer);
+};
+/**
+* Generates merkle proofs for all offers in a tree.
+*
+* Each proof allows independent verification that an offer is included in the tree
+* without requiring the full tree. Proofs are ordered by StandardMerkleTree leaf ordering.
+*
+* @param tree - The {@link Tree} to generate proofs for.
+* @returns Array of proofs - {@link Proof}
+*/
+const proofs = (tree) => {
+	return tree.offers.map((offer) => {
+		return {
+			offer,
+			path: tree.getProof([hash(offer)])
+		};
+	});
+};
+const normalizeSignatureDomain = (domain, errorFactory) => {
+	let chainId;
+	try {
+		chainId = typeof domain.chainId === "bigint" ? domain.chainId : BigInt(domain.chainId);
+	} catch {
+		throw errorFactory("invalid chainId");
+	}
+	if (chainId < 0n) throw errorFactory("invalid chainId");
+	if (!isAddress(domain.verifyingContract)) throw errorFactory("invalid verifyingContract");
+	return {
+		chainId,
+		verifyingContract: domain.verifyingContract.toLowerCase()
+	};
+};
+const assertHex = (value, expectedBytes, name, errorFactory = (reason) => new DecodeError(reason)) => {
+	if (typeof value !== "string" || !isHex(value)) throw errorFactory(`${name} is not a valid hex string`);
+	if (hexToBytes(value).length !== expectedBytes) throw errorFactory(`${name}: expected ${expectedBytes} bytes`);
+};
+const verifySignatureAndRecoverAddress = async (params) => {
+	const { root, signature, domain, errorFactory } = params;
+	assertHex(root, 32, "root", errorFactory);
+	assertHex(signature, 65, "signature", errorFactory);
+	const hash = hashTypedData({
+		domain,
+		types: signatureTypes,
+		primaryType: "Root",
+		message: { root }
+	});
+	try {
+		return await recoverAddress({
+			hash,
+			signature
+		});
+	} catch {
+		throw errorFactory("signature recovery failed");
+	}
+};
+/**
+* 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, domain) => {
+	if (VERSION$1 > 255) throw new EncodeError(`version overflow: ${VERSION$1} exceeds 255`);
+	const computed = from$7(tree.offers);
+	if (tree.root !== computed.root) throw new EncodeError(`root mismatch: expected ${computed.root}, got ${tree.root}`);
+	if (domain) {
+		const mismatched = tree.offers.find((offer) => BigInt(offer.chainId) !== domain.chainId);
+		if (mismatched) throw new EncodeError(`chainId mismatch: expected ${domain.chainId}, got ${mismatched.chainId}`);
+	}
+};
+const encodeUnsignedBytes = (tree) => {
+	const offersPayload = tree.offers.map(serialize);
+	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 hex calldata into a validated merkle tree.
+*
+* Validates signature before decompression for fail-fast rejection of invalid payloads.
+* Returns the tree with separately validated signature and recovered signer address.
+*
+* 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, { chainId, verifyingContract });
+* console.log(`Tree signed by ${signer} with ${tree.offers.length} offers`);
+* ```
+*
+* @param encoded - Hex calldata in format `0x{vv}{gzip}{root}{signature}`
+* @param domain - EIP-712 domain with chain id and verifying contract
+* @returns Validated tree, signature, and recovered signer address
+* @throws {DecodeError} If version invalid, signature invalid, or root mismatch
+*/
+const decode = async (encoded, domain) => {
+	const errorFactory = (reason) => new DecodeError(reason);
+	const normalizedDomain = normalizeSignatureDomain(domain, errorFactory);
+	const bytes = hexToBytes(encoded);
+	if (bytes.length < 98) throw new DecodeError("payload too short");
+	const version = bytes[0];
+	if (version !== (VERSION$1 & 255)) throw new DecodeError(`invalid version: expected ${VERSION$1}, got ${version ?? 0}`);
+	const signature = bytesToHex(bytes.slice(-65));
+	const root = bytesToHex(bytes.slice(-97, -65));
+	assertHex(root, 32, "root");
+	assertHex(signature, 65, "signature");
+	const signer = await verifySignatureAndRecoverAddress({
+		root,
+		signature,
+		domain: normalizedDomain,
+		errorFactory
+	});
+	const compressed = bytes.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$7(rawOffers.map((o) => OfferSchema().parse(o)));
+	if (root !== tree.root) throw new DecodeError(`root mismatch: expected ${tree.root}, got ${root}`);
+	const chainIdMismatch = tree.offers.find((offer) => BigInt(offer.chainId) !== normalizedDomain.chainId);
+	if (chainIdMismatch) throw new DecodeError(`chainId mismatch: expected ${normalizedDomain.chainId}, got ${chainIdMismatch.chainId}`);
+	return {
+		tree,
+		signature,
+		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.
+*/
+var DecodeError = class extends BaseError {
+	name = "Tree.DecodeError";
+	constructor(reason) {
+		super(`Failed to decode tree: ${reason}`);
+	}
+};
+
+//#endregion
+//#region src/core/types.ts
+const BrandTypeId = Symbol.for("mempool/Brand");
+
+//#endregion
+//#region src/gatekeeper/Rules.ts
+const chains$1 = ({ chains }) => single("chain_ids", `Validates that offer chain is one of: [${chains.map((c) => c.id).join(", ")}]`, (offer) => {
+	const allowedChainIds = chains.map((c) => c.id);
+	if (!allowedChainIds.some((id) => id === offer.chainId)) return { message: `Chain ID ${offer.chainId} is not in the allowed chains (${allowedChainIds.join(", ")})` };
+});
+const maturity = ({ maturities }) => single("maturity", `Validates that offer maturity is one of: [${maturities.join(", ")}]`, (offer) => {
+	const allowedMaturities = maturities.map((m) => from$16(m));
+	if (!allowedMaturities.includes(offer.maturity)) return { message: `Maturity must be end of current month (${allowedMaturities[0]}) or end of next month (${allowedMaturities[1]}). Got: ${offer.maturity}` };
+});
+const callback = ({ callbacks, allowedAddresses }) => single("callback", `Validates callbacks: buy empty callback is ${callbacks.includes(Type$1.BuyWithEmptyCallback) ? "allowed" : "not allowed"}; sell offers must use a non-empty callback; non-empty callbacks must target one of [${allowedAddresses.map((a) => a.toLowerCase()).join(", ")}]`, (offer) => {
+	if (isEmptyCallback(offer) && offer.buy && !callbacks?.find((c) => c === Type$1.BuyWithEmptyCallback)) return { message: "Buy offers with empty callback not allowed." };
+	if (isEmptyCallback(offer) && !offer.buy) return { message: "Sell offers require a non-empty callback." };
+	if (!isEmptyCallback(offer)) {
+		if (!allowedAddresses.includes(offer.callback.address?.toLowerCase())) return { message: `Callback address ${offer.callback.address} is not allowed.` };
+	}
+});
+/**
+* A validation rule that checks if the offer's tokens are allowed for its chain.
+* @param assetsByChainId - Allowed assets indexed by chain id.
+* @returns The issue that was found. If the offer is valid, this will be undefined.
+*/
+const token = ({ assetsByChainId }) => single("token", "Validates that offer loan token and collateral tokens are in the allowed assets list for the offer chain", (offer) => {
+	const allowedAssets = assetsByChainId[offer.chainId]?.map((asset) => asset.toLowerCase());
+	if (!allowedAssets || allowedAssets.length === 0) return { message: `No allowed assets for chain ${offer.chainId}` };
+	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 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 address", (offers) => {
+	const issues = /* @__PURE__ */ new Map();
+	if (offers.length === 0) return issues;
+	const firstMaker = offers[0].maker.toLowerCase();
+	for (let i = 1; i < offers.length; i++) {
+		const offer = offers[i];
+		if (offer.maker.toLowerCase() !== firstMaker) {
+			issues.set(i, { message: `Offer has different maker ${offer.maker} than first offer ${offers[0].maker}` });
+			return issues;
 		}
 	}
 	return issues;
@@ -2935,171 +2965,78 @@ const morphoRules = (chains) => {
 };
 
 //#endregion
-//#region src/api/Controllers/Payload.ts
-const API_ERROR_CODES = [
-	"VALIDATION_ERROR",
-	"NOT_FOUND",
-	"INTERNAL_SERVER_ERROR",
-	"BAD_REQUEST"
-];
-let STATUS_CODE = /* @__PURE__ */ function(STATUS_CODE) {
-	STATUS_CODE[STATUS_CODE["SUCCESS"] = 200] = "SUCCESS";
-	STATUS_CODE[STATUS_CODE["BAD_REQUEST"] = 400] = "BAD_REQUEST";
-	STATUS_CODE[STATUS_CODE["NOT_FOUND"] = 404] = "NOT_FOUND";
-	STATUS_CODE[STATUS_CODE["INTERNAL_SERVER_ERROR"] = 500] = "INTERNAL_SERVER_ERROR";
-	return STATUS_CODE;
-}({});
-var APIError = class extends Error {
-	constructor(statusCode, message, code, details) {
-		super(message);
-		this.statusCode = statusCode;
-		this.code = code;
-		this.details = details;
-		this.name = "APIError";
-	}
-};
-var ValidationError = class extends APIError {
-	constructor(message, details) {
-		super(STATUS_CODE.BAD_REQUEST, message, "VALIDATION_ERROR", details);
-	}
-};
-var NotFoundError = class extends APIError {
-	constructor(message) {
-		super(STATUS_CODE.NOT_FOUND, message, "NOT_FOUND");
-	}
-};
-var InternalServerError = class extends APIError {
-	constructor(message = "Internal server error") {
-		super(STATUS_CODE.INTERNAL_SERVER_ERROR, message, "INTERNAL_SERVER_ERROR");
-	}
-};
-var BadRequestError = class extends APIError {
-	constructor(message = "Invalid JSON format", details) {
-		super(STATUS_CODE.BAD_REQUEST, message, "BAD_REQUEST", details);
-	}
-};
-function success(args) {
-	const { data, cursor } = args;
-	return {
-		statusCode: STATUS_CODE.SUCCESS,
-		body: {
-			meta: { timestamp: (/* @__PURE__ */ new Date()).toISOString() },
-			cursor: cursor ?? null,
-			data
-		}
-	};
-}
+//#region src/gatekeeper/ConfigRules.ts
 /**
-* Generic failure builder. Preserves the concrete status code when the input is an APIError.
-* If not an APIError, maps to INTERNAL_SERVER_ERROR. Zod & SyntaxError are mapped to BAD_REQUEST.
+* Build the configured rules (maturities + callback addresses + loan tokens) for the provided chains.
+* @param chains - Chains to include in the configured rules.
+* @returns Sorted list of config rules.
 */
-function failure(err) {
-	if (err instanceof APIError) return handleAPIError(err);
-	if (err instanceof SyntaxError) return handleAPIError(new BadRequestError(err.message));
-	if (err instanceof z$2.ZodError) return handleAPIError(handleZodError(err));
-	return handleAPIError(new InternalServerError());
-}
-function handleAPIError(error) {
-	return {
-		statusCode: error.statusCode,
-		body: {
-			meta: { timestamp: (/* @__PURE__ */ new Date()).toISOString() },
-			error: {
-				code: error.code,
-				message: error.message,
-				...error.details && typeof error.details === "object" ? { details: error.details } : {}
-			}
-		}
-	};
-}
-function handleZodError(error) {
-	return new ValidationError("Validation failed", error.issues.map((issue) => {
-		const field = issue.path.join(".");
-		let msg = issue.message;
-		switch (issue.code) {
-			case "invalid_type":
-				if (issue.message.includes("received undefined")) msg = `${field} is required`;
-				break;
-			case "invalid_format":
-				msg = issue.format === "regex" ? issue.message : `${field} has an invalid format`;
-				break;
-			default: break;
-		}
-		return {
-			field,
-			issue: msg
-		};
-	}));
-}
-
-//#endregion
-//#region src/logger/Logger.ts
-const LogLevelValues = [
-	"trace",
-	"debug",
-	"info",
-	"warn",
-	"error",
-	"fatal",
-	"silent"
-];
-function defaultLogger(minLevel, pretty) {
-	const threshold = minLevel ?? process.env.ROUTER_LOG_LEVEL ?? "info";
-	const prettyEnabled = typeof pretty === "boolean" ? pretty : String(process.env.ROUTER_LOG_PRETTY ?? "false").toLowerCase() === "true";
-	const levelIndexByName = LogLevelValues.reduce((acc, lvl, idx) => {
-		acc[lvl] = idx;
-		return acc;
-	}, {});
-	const isEnabled = (methodLevel) => levelIndexByName[methodLevel] >= levelIndexByName[threshold];
-	const wrap = (consoleMethod, methodLevel) => isEnabled(methodLevel) ? (entry) => {
-		if (!prettyEnabled) {
-			console[consoleMethod](stringify({
-				level: methodLevel,
-				...entry
-			}));
-			return;
+function buildConfigRules(chains) {
+	const rules = [];
+	for (const chain of chains) {
+		const config = configs[chain.name];
+		const maturities = config.maturities ?? [];
+		for (const maturityName of maturities) rules.push({
+			type: "maturity",
+			chain_id: chain.id,
+			name: maturityName,
+			timestamp: from$16(maturityName)
+		});
+		const callbacks = config.callbacks ?? [];
+		for (const callback of callbacks) {
+			if (callback.type === Type$1.BuyWithEmptyCallback) continue;
+			if (!("addresses" in callback)) continue;
+			for (const address of callback.addresses) rules.push({
+				type: "callback",
+				chain_id: chain.id,
+				address: normalizeAddress(address),
+				callback_type: callback.type
+			});
 		}
-		const { msg, ...rest } = entry;
-		const stack = typeof rest.stack === "string" ? rest.stack : void 0;
-		if (stack) delete rest.stack;
-		const timestamp = (/* @__PURE__ */ new Date()).toISOString();
-		const level = methodLevel.toUpperCase();
-		const extras = Object.entries(rest).map(([k, v]) => `${k}=${formatValue(v)}`).join(" ");
-		const line = extras.length > 0 ? `${timestamp} [${level}] ${msg}  ${extras}` : `${timestamp} [${level}] ${msg}`;
-		console[consoleMethod](line);
-		if (stack) console[consoleMethod](stack);
-	} : () => {};
-	return {
-		trace: wrap("trace", "trace"),
-		debug: wrap("debug", "debug"),
-		info: wrap("info", "info"),
-		warn: wrap("warn", "warn"),
-		error: wrap("error", "error"),
-		fatal: wrap("error", "fatal")
-	};
-}
-const loggerContext = new AsyncLocalStorage();
-function runWithLogger(logger, fn) {
-	return loggerContext.run(logger, fn);
-}
-function getLogger() {
-	return loggerContext.getStore() ?? defaultLogger();
-}
-function formatValue(value) {
-	if (value === null || value === void 0 || typeof value === "number" || typeof value === "bigint" || typeof value === "boolean") return String(value);
-	if (typeof value === "string") {
-		if (value.includes(" ")) return JSON.stringify(value);
-		return value;
+		const loanTokens = assets[chain.id.toString()] ?? [];
+		for (const address of loanTokens) rules.push({
+			type: "loan_token",
+			chain_id: chain.id,
+			address: normalizeAddress(address)
+		});
 	}
-	try {
-		return stringify(value);
-	} catch {
-		try {
-			return JSON.stringify(value);
-		} catch {
-			return String(value);
+	rules.sort(compareConfigRules);
+	return rules;
+}
+/**
+* Compute a stable checksum for the provided configured rules.
+* @param rules - Configured rules to checksum.
+* @returns MD5 checksum.
+*/
+function buildConfigRulesChecksum(rules) {
+	const hash = createHash("md5");
+	const orderedRules = [...rules].sort(compareConfigRules);
+	for (const rule of orderedRules) {
+		if (rule.type === "maturity") {
+			hash.update(`maturity:${rule.chain_id}:${rule.name}:${rule.timestamp}\n`);
+			continue;
+		}
+		if (rule.type === "callback") {
+			hash.update(`callback:${rule.chain_id}:${rule.callback_type}:${rule.address}\n`);
+			continue;
 		}
+		hash.update(`loan_token:${rule.chain_id}:${rule.address}\n`);
+	}
+	return hash.digest("hex");
+}
+function normalizeAddress(address) {
+	return address.toLowerCase();
+}
+function compareConfigRules(left, right) {
+	if (left.chain_id !== right.chain_id) return left.chain_id - right.chain_id;
+	if (left.type !== right.type) return left.type.localeCompare(right.type);
+	if (left.type === "maturity" && right.type === "maturity") return left.timestamp - right.timestamp;
+	if (left.type === "callback" && right.type === "callback") {
+		if (left.callback_type !== right.callback_type) return left.callback_type.localeCompare(right.callback_type);
+		return left.address.localeCompare(right.address);
 	}
+	if (left.type === "loan_token" && right.type === "loan_token") return left.address.localeCompare(right.address);
+	return 0;
 }
 
 //#endregion
@@ -3229,6 +3166,104 @@ function from$4(input) {
 	};
 }
 
+//#endregion
+//#region src/api/Controllers/Payload.ts
+const API_ERROR_CODES = [
+	"VALIDATION_ERROR",
+	"NOT_FOUND",
+	"INTERNAL_SERVER_ERROR",
+	"BAD_REQUEST"
+];
+let STATUS_CODE = /* @__PURE__ */ function(STATUS_CODE) {
+	STATUS_CODE[STATUS_CODE["SUCCESS"] = 200] = "SUCCESS";
+	STATUS_CODE[STATUS_CODE["BAD_REQUEST"] = 400] = "BAD_REQUEST";
+	STATUS_CODE[STATUS_CODE["NOT_FOUND"] = 404] = "NOT_FOUND";
+	STATUS_CODE[STATUS_CODE["INTERNAL_SERVER_ERROR"] = 500] = "INTERNAL_SERVER_ERROR";
+	return STATUS_CODE;
+}({});
+var APIError = class extends Error {
+	constructor(statusCode, message, code, details) {
+		super(message);
+		this.statusCode = statusCode;
+		this.code = code;
+		this.details = details;
+		this.name = "APIError";
+	}
+};
+var ValidationError = class extends APIError {
+	constructor(message, details) {
+		super(STATUS_CODE.BAD_REQUEST, message, "VALIDATION_ERROR", details);
+	}
+};
+var NotFoundError = class extends APIError {
+	constructor(message) {
+		super(STATUS_CODE.NOT_FOUND, message, "NOT_FOUND");
+	}
+};
+var InternalServerError = class extends APIError {
+	constructor(message = "Internal server error") {
+		super(STATUS_CODE.INTERNAL_SERVER_ERROR, message, "INTERNAL_SERVER_ERROR");
+	}
+};
+var BadRequestError = class extends APIError {
+	constructor(message = "Invalid JSON format", details) {
+		super(STATUS_CODE.BAD_REQUEST, message, "BAD_REQUEST", details);
+	}
+};
+function success(args) {
+	const { data, cursor } = args;
+	return {
+		statusCode: STATUS_CODE.SUCCESS,
+		body: {
+			meta: { timestamp: (/* @__PURE__ */ new Date()).toISOString() },
+			cursor: cursor ?? null,
+			data
+		}
+	};
+}
+/**
+* Generic failure builder. Preserves the concrete status code when the input is an APIError.
+* If not an APIError, maps to INTERNAL_SERVER_ERROR. Zod & SyntaxError are mapped to BAD_REQUEST.
+*/
+function failure(err) {
+	if (err instanceof APIError) return handleAPIError(err);
+	if (err instanceof SyntaxError) return handleAPIError(new BadRequestError(err.message));
+	if (err instanceof z$2.ZodError) return handleAPIError(handleZodError(err));
+	return handleAPIError(new InternalServerError());
+}
+function handleAPIError(error) {
+	return {
+		statusCode: error.statusCode,
+		body: {
+			meta: { timestamp: (/* @__PURE__ */ new Date()).toISOString() },
+			error: {
+				code: error.code,
+				message: error.message,
+				...error.details && typeof error.details === "object" ? { details: error.details } : {}
+			}
+		}
+	};
+}
+function handleZodError(error) {
+	return new ValidationError("Validation failed", error.issues.map((issue) => {
+		const field = issue.path.join(".");
+		let msg = issue.message;
+		switch (issue.code) {
+			case "invalid_type":
+				if (issue.message.includes("received undefined")) msg = `${field} is required`;
+				break;
+			case "invalid_format":
+				msg = issue.format === "regex" ? issue.message : `${field} has an invalid format`;
+				break;
+			default: break;
+		}
+		return {
+			field,
+			issue: msg
+		};
+	}));
+}
+
 //#endregion
 //#region \0@oxc-project+runtime@0.110.0/helpers/decorate.js
 function __decorate(decorators, target, key, desc) {
@@ -3321,6 +3356,21 @@ const validateOfferExample = {
 		data: "0x00000000000000000000000000000000000000000000000000000000000000400000000000000000000000000000000000000000000000000000000000000080000000000000000000000000000000000000000000000000000000000000000100000000000000000000000034cf890db685fc536e05652fb41f02090c3fb751000000000000000000000000000000000000000000000000000000000000000100000000000000000000000000108e644e3ab01184155270aa92a00000000000"
 	}
 };
+const callbackTypesRequestExample = { callbacks: [{
+	chain_id: 1,
+	addresses: [
+		"0x1111111111111111111111111111111111111111",
+		"0x3333333333333333333333333333333333333333",
+		"0x9999999999999999999999999999999999999999"
+	]
+}] };
+const callbackTypesResponseExample = [{
+	chain_id: 1,
+	sell_erc20_callback: ["0x1111111111111111111111111111111111111111"],
+	buy_erc20: ["0x5555555555555555555555555555555555555555"],
+	buy_vault_v1_callback: ["0x3333333333333333333333333333333333333333"],
+	not_supported: ["0x9999999999999999999999999999999999999999"]
+}];
 const routerStatusExample = {
 	status: "live",
 	initialized: true,
@@ -3389,6 +3439,55 @@ __decorate([ApiProperty({
 	type: "string",
 	example: validateOfferExample.callback.data
 })], ValidateCallbackRequest.prototype, "data", void 0);
+var CallbackTypesChainRequest = class {};
+__decorate([ApiProperty({
+	type: "number",
+	example: callbackTypesRequestExample.callbacks[0].chain_id
+})], CallbackTypesChainRequest.prototype, "chain_id", void 0);
+__decorate([ApiProperty({
+	type: () => [String],
+	example: callbackTypesRequestExample.callbacks[0].addresses
+})], CallbackTypesChainRequest.prototype, "addresses", void 0);
+var CallbackTypesRequest = class {};
+__decorate([ApiProperty({
+	type: () => [CallbackTypesChainRequest],
+	example: callbackTypesRequestExample.callbacks
+})], CallbackTypesRequest.prototype, "callbacks", void 0);
+var CallbackTypesChainResponse = class {};
+__decorate([ApiProperty({
+	type: "number",
+	example: callbackTypesResponseExample[0].chain_id
+})], CallbackTypesChainResponse.prototype, "chain_id", void 0);
+__decorate([ApiProperty({
+	type: () => [String],
+	required: false,
+	example: callbackTypesResponseExample[0].buy_vault_v1_callback
+})], CallbackTypesChainResponse.prototype, "buy_vault_v1_callback", void 0);
+__decorate([ApiProperty({
+	type: () => [String],
+	required: false,
+	example: callbackTypesResponseExample[0].sell_erc20_callback
+})], CallbackTypesChainResponse.prototype, "sell_erc20_callback", void 0);
+__decorate([ApiProperty({
+	type: () => [String],
+	required: false,
+	example: callbackTypesResponseExample[0].buy_erc20
+})], CallbackTypesChainResponse.prototype, "buy_erc20", void 0);
+__decorate([ApiProperty({
+	type: () => [String],
+	example: callbackTypesResponseExample[0].not_supported
+})], CallbackTypesChainResponse.prototype, "not_supported", void 0);
+var CallbackTypesSuccessResponse = class extends SuccessResponse {};
+__decorate([ApiProperty({
+	type: "string",
+	nullable: true,
+	example: "maturity:1:1730415600:end_of_next_month"
+})], CallbackTypesSuccessResponse.prototype, "cursor", void 0);
+__decorate([ApiProperty({
+	type: () => [CallbackTypesChainResponse],
+	description: "Callback types grouped by chain.",
+	example: callbackTypesResponseExample
+})], CallbackTypesSuccessResponse.prototype, "data", void 0);
 var AskResponse = class {};
 __decorate([ApiProperty({
 	type: "string",
@@ -3924,6 +4023,28 @@ ValidateController = __decorate([ApiTags("Make"), ApiResponse({
 	description: "Bad Request",
 	type: BadRequestResponse
 })], ValidateController);
+let CallbacksController = class CallbacksController {
+	async resolveCallbackTypes() {}
+};
+__decorate([
+	ApiOperation({
+		methods: ["post"],
+		path: "/v1/callbacks",
+		summary: "Resolve callback types",
+		description: "Returns callback types for callback addresses grouped by chain."
+	}),
+	ApiBody({ type: CallbackTypesRequest }),
+	ApiResponse({
+		status: 200,
+		description: "Success",
+		type: CallbackTypesSuccessResponse
+	})
+], CallbacksController.prototype, "resolveCallbackTypes", null);
+CallbacksController = __decorate([ApiTags("Make"), ApiResponse({
+	status: 400,
+	description: "Bad Request",
+	type: BadRequestResponse
+})], CallbacksController);
 let OffersController = class OffersController {
 	async getOffers() {}
 };
@@ -3992,107 +4113,274 @@ __decorate([
 		description: "Returns the aggregated status of the router."
 	}),
 	ApiQuery({
-		name: "strict",
-		type: "boolean",
+		name: "strict",
+		type: "boolean",
+		required: false,
+		example: true,
+		description: "Fail the request if initialization is incomplete."
+	}),
+	ApiResponse({
+		status: 200,
+		description: "Success",
+		type: RouterStatusSuccessResponse
+	})
+], HealthController.prototype, "getRouterStatus", null);
+__decorate([
+	ApiOperation({
+		methods: ["get"],
+		path: "/v1/health/collectors",
+		summary: "Retrieve collectors health",
+		description: "Returns the latest block numbers processed by collectors and their sync status."
+	}),
+	ApiQuery({
+		name: "strict",
+		type: "boolean",
+		required: false,
+		example: true,
+		description: "Fail the request if initialization is incomplete."
+	}),
+	ApiResponse({
+		status: 200,
+		description: "Success",
+		type: CollectorsHealthSuccessResponse
+	})
+], HealthController.prototype, "getCollectorsHealth", null);
+__decorate([
+	ApiOperation({
+		methods: ["get"],
+		path: "/v1/health/chains",
+		summary: "Retrieve chains health",
+		description: "Returns the latest block that can be processed by collectors for each chain."
+	}),
+	ApiQuery({
+		name: "strict",
+		type: "boolean",
+		required: false,
+		example: true,
+		description: "Fail the request if initialization is incomplete."
+	}),
+	ApiResponse({
+		status: 200,
+		description: "Success",
+		type: ChainsHealthSuccessResponse
+	})
+], HealthController.prototype, "getChainsHealth", null);
+HealthController = __decorate([ApiTags("System")], HealthController);
+const configContractsExample = {
+	chain_id: 505050505,
+	address: "0xD946246695A9259F3B33a78629026F61B3Ab40aF",
+	name: "mempool"
+};
+const configContractsPayloadExample = [
+	{
+		chain_id: 505050505,
+		address: "0xD946246695A9259F3B33a78629026F61B3Ab40aF",
+		name: "mempool"
+	},
+	{
+		chain_id: 505050505,
+		address: "0x8A409D5D6394fC197c596d4E6E2c35e5d13f8a4d",
+		name: "multicall"
+	},
+	{
+		chain_id: 505050505,
+		address: "0x23DFBc4B8B80C14CC5e25011B8491f268395BAd6",
+		name: "v2"
+	}
+];
+const configRulesMaturityExample = {
+	type: "maturity",
+	chain_id: 1,
+	name: "end_of_next_month",
+	timestamp: 1730415600
+};
+const configRulesCallbackExample = {
+	type: "callback",
+	chain_id: 1,
+	address: "0x1111111111111111111111111111111111111111",
+	callback_type: "sell_erc20_callback"
+};
+const configRulesLoanTokenExample = {
+	type: "loan_token",
+	chain_id: 1,
+	address: "0xA0b86991c6218b36c1d19D4a2e9Eb0cE3606eB48"
+};
+const configRulesChecksumExample = "f1d2d2f924e986ac86fdf7b36c94bcdf";
+const configRulesPayloadExample = [
+	configRulesMaturityExample,
+	configRulesCallbackExample,
+	configRulesLoanTokenExample
+];
+const configContractNames = [
+	"mempool",
+	"multicall",
+	"v2"
+];
+const configContractsCursorExample = "505050505:0xd946246695a9259f3b33a78629026f61b3ab40af";
+var ConfigContractResponse = class {};
+__decorate([ApiProperty({
+	type: "number",
+	example: configContractsExample.chain_id
+})], ConfigContractResponse.prototype, "chain_id", void 0);
+__decorate([ApiProperty({
+	type: "string",
+	example: configContractsExample.address
+})], ConfigContractResponse.prototype, "address", void 0);
+__decorate([ApiProperty({
+	type: "string",
+	enum: configContractNames,
+	example: configContractsExample.name
+})], ConfigContractResponse.prototype, "name", void 0);
+var ConfigContractsSuccessResponse = class extends SuccessResponse {};
+__decorate([ApiProperty({
+	type: "string",
+	nullable: true,
+	example: null
+})], ConfigContractsSuccessResponse.prototype, "cursor", void 0);
+__decorate([ApiProperty({
+	type: () => [ConfigContractResponse],
+	description: "Indexer contract configuration for all indexed chains.",
+	example: configContractsPayloadExample
+})], ConfigContractsSuccessResponse.prototype, "data", void 0);
+var ConfigRulesMeta = class {};
+__decorate([ApiProperty({
+	type: "string",
+	example: timestampExample
+})], ConfigRulesMeta.prototype, "timestamp", void 0);
+__decorate([ApiProperty({
+	type: "string",
+	example: configRulesChecksumExample
+})], ConfigRulesMeta.prototype, "checksum", void 0);
+var ConfigRulesRuleResponse = class {};
+__decorate([ApiProperty({
+	type: "string",
+	example: configRulesMaturityExample.type
+})], ConfigRulesRuleResponse.prototype, "type", void 0);
+__decorate([ApiProperty({
+	type: "number",
+	example: configRulesMaturityExample.chain_id
+})], ConfigRulesRuleResponse.prototype, "chain_id", void 0);
+__decorate([ApiProperty({
+	type: "string",
+	example: configRulesMaturityExample.name,
+	required: false
+})], ConfigRulesRuleResponse.prototype, "name", void 0);
+__decorate([ApiProperty({
+	type: "number",
+	example: configRulesMaturityExample.timestamp,
+	required: false
+})], ConfigRulesRuleResponse.prototype, "timestamp", void 0);
+__decorate([ApiProperty({
+	type: "string",
+	example: configRulesCallbackExample.address,
+	required: false
+})], ConfigRulesRuleResponse.prototype, "address", void 0);
+__decorate([ApiProperty({
+	type: "string",
+	example: configRulesCallbackExample.callback_type,
+	required: false
+})], ConfigRulesRuleResponse.prototype, "callback_type", void 0);
+var ConfigRulesSuccessResponse = class {};
+__decorate([ApiProperty({ type: () => ConfigRulesMeta })], ConfigRulesSuccessResponse.prototype, "meta", void 0);
+__decorate([ApiProperty({
+	type: "string",
+	nullable: true,
+	example: null
+})], ConfigRulesSuccessResponse.prototype, "cursor", void 0);
+__decorate([ApiProperty({
+	type: () => [ConfigRulesRuleResponse],
+	description: "Configured rules returned by the router API.",
+	example: configRulesPayloadExample
+})], ConfigRulesSuccessResponse.prototype, "data", void 0);
+let ConfigContractsController = class ConfigContractsController {
+	async getConfigContracts() {}
+};
+__decorate([
+	ApiOperation({
+		methods: ["get"],
+		path: "/v1/config/contracts",
+		summary: "Get indexer contract configuration",
+		description: "Returns contract addresses used by indexers (mempool, v2) and multicall for indexed chains."
+	}),
+	ApiQuery({
+		name: "cursor",
+		type: "string",
+		required: false,
+		example: configContractsCursorExample,
+		description: "Pagination cursor in chain_id:address format (lowercase address)."
+	}),
+	ApiQuery({
+		name: "limit",
+		type: "number",
+		required: false,
+		example: 1e3,
+		description: "Maximum number of contracts to return (max 1000)."
+	}),
+	ApiQuery({
+		name: "chains",
+		type: ["number"],
 		required: false,
-		example: true,
-		description: "Fail the request if initialization is incomplete."
+		example: "1,8453",
+		description: "Filter by chain IDs (comma-separated).",
+		style: "form",
+		explode: false
 	}),
 	ApiResponse({
 		status: 200,
 		description: "Success",
-		type: RouterStatusSuccessResponse
+		type: ConfigContractsSuccessResponse
 	})
-], HealthController.prototype, "getRouterStatus", null);
+], ConfigContractsController.prototype, "getConfigContracts", null);
+ConfigContractsController = __decorate([ApiTags("System")], ConfigContractsController);
+let ConfigRulesController = class ConfigRulesController {
+	async getConfigRules() {}
+};
 __decorate([
 	ApiOperation({
 		methods: ["get"],
-		path: "/v1/health/collectors",
-		summary: "Retrieve collectors health",
-		description: "Returns the latest block numbers processed by collectors and their sync status."
+		path: "/v1/config/rules",
+		summary: "Get config rules",
+		description: "Returns configured rules for supported chains."
 	}),
 	ApiQuery({
-		name: "strict",
-		type: "boolean",
+		name: "cursor",
+		type: "string",
 		required: false,
-		example: true,
-		description: "Fail the request if initialization is incomplete."
+		example: "maturity:1:1730415600:end_of_next_month",
+		description: "Pagination cursor in type:chain_id:<value> format."
 	}),
-	ApiResponse({
-		status: 200,
-		description: "Success",
-		type: CollectorsHealthSuccessResponse
-	})
-], HealthController.prototype, "getCollectorsHealth", null);
-__decorate([
-	ApiOperation({
-		methods: ["get"],
-		path: "/v1/health/chains",
-		summary: "Retrieve chains health",
-		description: "Returns the latest block that can be processed by collectors for each chain."
+	ApiQuery({
+		name: "limit",
+		type: "number",
+		required: false,
+		example: 100,
+		description: "Maximum number of rules to return (max 1000)."
 	}),
 	ApiQuery({
-		name: "strict",
-		type: "boolean",
+		name: "types",
+		type: ["string"],
 		required: false,
-		example: true,
-		description: "Fail the request if initialization is incomplete."
+		example: "maturity,loan_token",
+		description: "Filter by rule types (comma-separated).",
+		style: "form",
+		explode: false
+	}),
+	ApiQuery({
+		name: "chains",
+		type: ["number"],
+		required: false,
+		example: "1,8453",
+		description: "Filter by chain IDs (comma-separated).",
+		style: "form",
+		explode: false
 	}),
 	ApiResponse({
 		status: 200,
 		description: "Success",
-		type: ChainsHealthSuccessResponse
+		type: ConfigRulesSuccessResponse
 	})
-], HealthController.prototype, "getChainsHealth", null);
-HealthController = __decorate([ApiTags("System")], HealthController);
-const callbacksExample = [Type$1.BuyWithEmptyCallback];
-const chainConfigExample = {
-	chain_id: 505050505,
-	contracts: { mempool: "0xD946246695A9259F3B33a78629026F61B3Ab40aF" },
-	callbacks: callbacksExample
-};
-var ConfigContractsResponse = class {};
-__decorate([ApiProperty({
-	type: "string",
-	example: chainConfigExample.contracts.mempool
-})], ConfigContractsResponse.prototype, "mempool", void 0);
-var ConfigDataResponse = class {};
-__decorate([ApiProperty({
-	type: "number",
-	example: chainConfigExample.chain_id
-})], ConfigDataResponse.prototype, "chain_id", void 0);
-__decorate([ApiProperty({ type: () => ConfigContractsResponse })], ConfigDataResponse.prototype, "contracts", void 0);
-__decorate([ApiProperty({
-	type: () => [String],
-	enum: Object.values(Type$1),
-	description: "Supported callback types for this chain.",
-	example: callbacksExample
-})], ConfigDataResponse.prototype, "callbacks", void 0);
-var ConfigSuccessResponse = class extends SuccessResponse {};
-__decorate([ApiProperty({
-	type: "string",
-	nullable: true,
-	example: null
-})], ConfigSuccessResponse.prototype, "cursor", void 0);
-__decorate([ApiProperty({
-	type: () => [ConfigDataResponse],
-	description: "Array of chain configurations for all indexed chains.",
-	example: [chainConfigExample]
-})], ConfigSuccessResponse.prototype, "data", void 0);
-let ConfigController = class ConfigController {
-	async getConfig() {}
-};
-__decorate([ApiOperation({
-	methods: ["get"],
-	path: "/v1/config",
-	summary: "Get router configuration",
-	description: "Returns chain configurations including contract addresses and supported callback types."
-}), ApiResponse({
-	status: 200,
-	description: "Success",
-	type: ConfigSuccessResponse
-})], ConfigController.prototype, "getConfig", null);
-ConfigController = __decorate([ApiTags("System")], ConfigController);
+], ConfigRulesController.prototype, "getConfigRules", null);
+ConfigRulesController = __decorate([ApiTags("System")], ConfigRulesController);
 let ObligationsController = class ObligationsController {
 	async getObligations() {}
 	async getObligation() {}
@@ -4221,16 +4509,18 @@ UsersController = __decorate([ApiTags("Make"), ApiResponse({
 	description: "Bad Request",
 	type: BadRequestResponse
 })], UsersController);
-const OpenApi = async (options = {}) => {
-	const document = await generateDocument({
+const OpenApi = async () => {
+	return await generateDocument({
 		controllers: [
 			BooksController,
-			ConfigController,
+			ConfigContractsController,
+			ConfigRulesController,
 			OffersController,
 			ObligationsController,
 			HealthController,
 			UsersController,
-			ValidateController
+			ValidateController,
+			CallbacksController
 		],
 		document: {
 			openapi: "3.1.0",
@@ -4262,12 +4552,6 @@ 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 unsigned payload + root on success, or issues only on validation failure.\n\n**Available validation rules:**\n${rulesDescription}`;
-	}
-	return document;
 };
 
 //#endregion
@@ -4291,6 +4575,10 @@ function from$3(position) {
 //#region src/api/Schema/requests.ts
 const MAX_LIMIT = 100;
 const DEFAULT_LIMIT$4 = 20;
+const CONFIG_RULES_MAX_LIMIT = 1e3;
+const CONFIG_RULES_DEFAULT_LIMIT = 100;
+const CONFIG_CONTRACTS_MAX_LIMIT = 1e3;
+const CONFIG_CONTRACTS_DEFAULT_LIMIT = 1e3;
 /** Validate cursor is a valid base64url-encoded JSON object.
 * Domain layer handles semantic validation of cursor fields. */
 function isValidBase64urlJson(val) {
@@ -4324,6 +4612,43 @@ const PaginationQueryParams = z$2.object({
 		example: 10
 	})
 });
+const ConfigRuleTypes = z$2.enum([
+	"maturity",
+	"callback",
+	"loan_token"
+]);
+const GetConfigRulesQueryParams = z$2.object({
+	cursor: z$2.string().regex(/^(maturity|callback|loan_token):[1-9]\d*:.+$/, { message: "Cursor must be in the format type:chain_id:<value>" }).optional().meta({
+		description: "Pagination cursor in type:chain_id:<value> format",
+		example: "maturity:1:1730415600:end_of_next_month"
+	}),
+	limit: z$2.string().regex(/^[1-9]\d*$/, { message: "Limit must be a positive integer" }).transform((val) => Number.parseInt(val, 10)).pipe(z$2.number().max(CONFIG_RULES_MAX_LIMIT, { message: `Limit cannot exceed ${CONFIG_RULES_MAX_LIMIT}` })).optional().default(CONFIG_RULES_DEFAULT_LIMIT).meta({
+		description: `Limit maximum: ${CONFIG_RULES_MAX_LIMIT}. Default: ${CONFIG_RULES_DEFAULT_LIMIT}`,
+		example: 100
+	}),
+	types: csvArray(ConfigRuleTypes).meta({
+		description: "Filter by rule types (comma-separated).",
+		example: "maturity,loan_token"
+	}),
+	chains: csvArray(z$2.string().regex(/^[1-9]\d*$/, { message: "Chain must be a positive integer" }).transform((val) => Number.parseInt(val, 10))).meta({
+		description: "Filter by chain IDs (comma-separated).",
+		example: "1,8453"
+	})
+});
+const GetConfigContractsQueryParams = z$2.object({
+	cursor: z$2.string().regex(/^[1-9]\d*:0x[a-fA-F0-9]{40}$/, { message: "Cursor must be in the format chain_id:0x..." }).optional().meta({
+		description: "Pagination cursor in chain_id:address format (lowercase address).",
+		example: "1:0xa0b86991c6218b36c1d19d4a2e9eb0ce3606eb48"
+	}),
+	limit: z$2.string().regex(/^[1-9]\d*$/, { message: "Limit must be a positive integer" }).transform((val) => Number.parseInt(val, 10)).pipe(z$2.number().max(CONFIG_CONTRACTS_MAX_LIMIT, { message: `Limit cannot exceed ${CONFIG_CONTRACTS_MAX_LIMIT}` })).optional().default(CONFIG_CONTRACTS_DEFAULT_LIMIT).meta({
+		description: `Limit maximum: ${CONFIG_CONTRACTS_MAX_LIMIT}. Default: ${CONFIG_CONTRACTS_DEFAULT_LIMIT}`,
+		example: 1e3
+	}),
+	chains: csvArray(z$2.string().regex(/^[1-9]\d*$/, { message: "Chain must be a positive integer" }).transform((val) => Number.parseInt(val, 10))).meta({
+		description: "Filter by chain IDs (comma-separated).",
+		example: "1,8453"
+	})
+});
 const GetOffersQueryParams = z$2.object({
 	...PaginationQueryParams.shape,
 	side: z$2.enum(["buy", "sell"]).optional().meta({
@@ -4426,6 +4751,16 @@ const GetBookParams = z$2.object({
 	})
 });
 const ValidateOffersBody = z$2.object({ offers: z$2.array(z$2.unknown()).min(1, { message: "'offers' must contain at least 1 offer" }) }).strict();
+const CallbackTypesBody = z$2.object({ callbacks: z$2.array(z$2.object({
+	chain_id: z$2.number().int().positive().meta({
+		description: "Chain id.",
+		example: 1
+	}),
+	addresses: z$2.array(z$2.string().regex(/^0x[a-fA-F0-9]{40}$/, { error: "Callback address must be a valid 20-byte address" }).transform((val) => val.toLowerCase())).meta({
+		description: "Callback contract addresses.",
+		example: ["0x1111111111111111111111111111111111111111", "0x3333333333333333333333333333333333333333"]
+	})
+}).strict()) }).strict();
 const GetUserPositionsParams = z$2.object({
 	...PaginationQueryParams.shape,
 	user_address: z$2.string().regex(/^0x[a-fA-F0-9]{40}$/, { error: "User address must be a valid 20-byte address" }).transform((val) => val.toLowerCase()).meta({
@@ -4437,17 +4772,204 @@ const schemas = {
 	get_health: HealthQueryParams,
 	get_health_collectors: HealthQueryParams,
 	get_health_chains: HealthQueryParams,
+	get_config_contracts: GetConfigContractsQueryParams,
+	get_config_rules: GetConfigRulesQueryParams,
 	get_offers: GetOffersQueryParams,
 	get_obligations: GetObligationsQueryParams,
 	get_obligation: GetObligationParams,
 	get_book: GetBookParams,
 	validate_offers: ValidateOffersBody,
+	callback_types: CallbackTypesBody,
 	get_user_positions: GetUserPositionsParams
 };
 function safeParse(action, query, error) {
 	return schemas[action].safeParse(query, { error });
 }
 
+//#endregion
+//#region src/api/Controllers/getConfigRules.ts
+/**
+* Returns configured rules for the configured chains.
+* @param query - Raw query parameters containing filters/cursor/limit.
+* @param chains - Chains to include in the configured rules.
+* @returns Config rules response payload. {@link ApiPayload.Payload}
+*/
+async function getConfigRules(query, chains) {
+	const parsed = safeParse("get_config_rules", query ?? {});
+	if (!parsed.success) return failure(parsed.error);
+	const { cursor, limit, types, chains: chainIds } = parsed.data;
+	const typeFilter = types?.length ? new Set(types) : null;
+	const chainFilter = chainIds?.length ? new Set(chainIds) : null;
+	const filteredRules = buildConfigRules(chains).filter((rule) => {
+		if (chainFilter && !chainFilter.has(rule.chain_id)) return false;
+		if (typeFilter && !typeFilter.has(rule.type)) return false;
+		return true;
+	});
+	const checksum = buildConfigRulesChecksum(filteredRules);
+	let cursorRule = null;
+	if (cursor) try {
+		cursorRule = parseCursor$1(cursor);
+	} catch (err) {
+		return failure(err);
+	}
+	if (cursorRule && typeFilter && !typeFilter.has(cursorRule.type)) return failure(new BadRequestError("Cursor type must match requested rule types"));
+	if (cursorRule && chainFilter && !chainFilter.has(cursorRule.chain_id)) return failure(new BadRequestError("Cursor chain_id must match requested chains"));
+	const startIndex = cursorRule ? findStartIndex$1(filteredRules, cursorRule) : 0;
+	const page = filteredRules.slice(startIndex, startIndex + limit);
+	const nextCursor = startIndex + limit < filteredRules.length && page.length > 0 ? formatCursor$1(page.at(-1)) : null;
+	const response = success({
+		data: page,
+		cursor: nextCursor
+	});
+	response.body.meta.checksum = checksum;
+	return response;
+}
+function formatCursor$1(rule) {
+	if (rule.type === "maturity") return `maturity:${rule.chain_id}:${rule.timestamp}:${rule.name}`;
+	if (rule.type === "callback") return `callback:${rule.chain_id}:${rule.callback_type}:${rule.address.toLowerCase()}`;
+	return `loan_token:${rule.chain_id}:${rule.address.toLowerCase()}`;
+}
+function parseCursor$1(cursor) {
+	const [type, chain, ...rest] = cursor.split(":");
+	if (!type || !chain || rest.length === 0) throw new BadRequestError("Cursor must be in the format type:chain_id:<value>");
+	if (!isConfigRuleType(type)) throw new BadRequestError("Cursor has an invalid rule type");
+	const chain_id = Number.parseInt(chain, 10);
+	if (!Number.isFinite(chain_id)) throw new BadRequestError("Cursor has an invalid chain_id");
+	if (type === "maturity") {
+		const timestampValue = Number.parseInt(rest[0] ?? "", 10);
+		const nameValue = rest.slice(1).join(":");
+		if (!Number.isFinite(timestampValue) || nameValue.length === 0) throw new BadRequestError("Cursor must be in the format maturity:chain_id:timestamp:name");
+		if (!isMaturityType(nameValue)) throw new BadRequestError("Cursor has an invalid maturity name");
+		return {
+			type,
+			chain_id,
+			timestamp: parseMaturity(timestampValue),
+			name: nameValue
+		};
+	}
+	if (type === "callback") {
+		const callbackTypeValue = rest[0] ?? "";
+		const addressValue = rest.slice(1).join(":");
+		if (!callbackTypeValue || !addressValue) throw new BadRequestError("Cursor must be in the format callback:chain_id:callback_type:address");
+		if (!isCallbackType(callbackTypeValue)) throw new BadRequestError("Cursor has an invalid callback type");
+		return {
+			type,
+			chain_id,
+			callback_type: callbackTypeValue,
+			address: parseAddress(addressValue, "Cursor address")
+		};
+	}
+	const addressValue = rest.join(":");
+	if (!addressValue) throw new BadRequestError("Cursor must be in the format loan_token:chain_id:address");
+	return {
+		type,
+		chain_id,
+		address: parseAddress(addressValue, "Cursor address")
+	};
+}
+function findStartIndex$1(rules, cursor) {
+	let low = 0;
+	let high = rules.length;
+	while (low < high) {
+		const mid = Math.floor((low + high) / 2);
+		const current = rules[mid];
+		if (compareConfigRules(current, cursor) <= 0) low = mid + 1;
+		else high = mid;
+	}
+	return low;
+}
+function parseAddress(address, label) {
+	if (!/^0x[a-fA-F0-9]{40}$/.test(address)) throw new BadRequestError(`${label} must be a valid 20-byte address`);
+	return address.toLowerCase();
+}
+function isConfigRuleType(value) {
+	return value === "maturity" || value === "callback" || value === "loan_token";
+}
+function isMaturityType(value) {
+	return Object.values(MaturityType).includes(value);
+}
+function parseMaturity(value) {
+	try {
+		return from$16(value);
+	} catch (err) {
+		throw new BadRequestError(err instanceof Error ? err.message : "Invalid maturity timestamp");
+	}
+}
+function isCallbackType(value) {
+	if (value === Type$1.BuyWithEmptyCallback) return false;
+	return Object.values(Type$1).includes(value);
+}
+
+//#endregion
+//#region src/logger/Logger.ts
+const LogLevelValues = [
+	"trace",
+	"debug",
+	"info",
+	"warn",
+	"error",
+	"fatal",
+	"silent"
+];
+function defaultLogger(minLevel, pretty) {
+	const threshold = minLevel ?? process.env.ROUTER_LOG_LEVEL ?? "info";
+	const prettyEnabled = typeof pretty === "boolean" ? pretty : String(process.env.ROUTER_LOG_PRETTY ?? "false").toLowerCase() === "true";
+	const levelIndexByName = LogLevelValues.reduce((acc, lvl, idx) => {
+		acc[lvl] = idx;
+		return acc;
+	}, {});
+	const isEnabled = (methodLevel) => levelIndexByName[methodLevel] >= levelIndexByName[threshold];
+	const wrap = (consoleMethod, methodLevel) => isEnabled(methodLevel) ? (entry) => {
+		if (!prettyEnabled) {
+			console[consoleMethod](stringify({
+				level: methodLevel,
+				...entry
+			}));
+			return;
+		}
+		const { msg, ...rest } = entry;
+		const stack = typeof rest.stack === "string" ? rest.stack : void 0;
+		if (stack) delete rest.stack;
+		const timestamp = (/* @__PURE__ */ new Date()).toISOString();
+		const level = methodLevel.toUpperCase();
+		const extras = Object.entries(rest).map(([k, v]) => `${k}=${formatValue(v)}`).join(" ");
+		const line = extras.length > 0 ? `${timestamp} [${level}] ${msg}  ${extras}` : `${timestamp} [${level}] ${msg}`;
+		console[consoleMethod](line);
+		if (stack) console[consoleMethod](stack);
+	} : () => {};
+	return {
+		trace: wrap("trace", "trace"),
+		debug: wrap("debug", "debug"),
+		info: wrap("info", "info"),
+		warn: wrap("warn", "warn"),
+		error: wrap("error", "error"),
+		fatal: wrap("error", "fatal")
+	};
+}
+const loggerContext = new AsyncLocalStorage();
+function runWithLogger(logger, fn) {
+	return loggerContext.run(logger, fn);
+}
+function getLogger() {
+	return loggerContext.getStore() ?? defaultLogger();
+}
+function formatValue(value) {
+	if (value === null || value === void 0 || typeof value === "number" || typeof value === "bigint" || typeof value === "boolean") return String(value);
+	if (typeof value === "string") {
+		if (value.includes(" ")) return JSON.stringify(value);
+		return value;
+	}
+	try {
+		return stringify(value);
+	} catch {
+		try {
+			return JSON.stringify(value);
+		} catch {
+			return String(value);
+		}
+	}
+}
+
 //#endregion
 //#region src/api/Controllers/validateOffers.ts
 async function validateOffers(body, gatekeeper) {
@@ -4461,9 +4983,9 @@ async function validateOffers(body, gatekeeper) {
 		const rawOffer = rawOffers[i];
 		try {
 			const offer = fromSnakeCase(rawOffer);
-			const hash$2 = hash(offer);
-			if (!offerIndexByHash.has(hash$2)) {
-				offerIndexByHash.set(hash$2, i);
+			const hash$3 = hash(offer);
+			if (!offerIndexByHash.has(hash$3)) {
+				offerIndexByHash.set(hash$3, i);
 				parsedOffers.push(offer);
 			}
 		} catch (err) {
@@ -4489,7 +5011,7 @@ async function validateOffers(body, gatekeeper) {
 				cursor: null
 			});
 		}
-		const tree = from$12(parsedOffers);
+		const tree = from$7(parsedOffers);
 		const payload = encodeUnsigned(tree);
 		return success({
 			data: {
@@ -4509,6 +5031,35 @@ async function validateOffers(body, gatekeeper) {
 	}
 }
 
+//#endregion
+//#region src/gatekeeper/CallbackTypes.ts
+/**
+* Resolve callback types for a list of callback addresses grouped by chain.
+* @param parameters - Resolve parameters. {@link resolveCallbackTypes.Parameters}
+* @returns Callback types grouped by chain. {@link resolveCallbackTypes.ReturnType}
+* @throws If a chain id is unknown.
+*/
+function resolveCallbackTypes$2(parameters) {
+	const { chains, request } = parameters;
+	const chainsById = new Map(chains.map((chain) => [chain.id, chain]));
+	return request.callbacks.map(({ chain_id, addresses }) => {
+		const chain = chainsById.get(chain_id);
+		if (!chain) throw new Error(`Unknown chain id ${chain_id}`);
+		const buckets = /* @__PURE__ */ new Map();
+		const uniqueAddresses = new Set(addresses.map((address) => address.toLowerCase()));
+		for (const address of uniqueAddresses) {
+			const bucketKey = getCallbackType(chain.name, address) ?? "not_supported";
+			const list = buckets.get(bucketKey) ?? [];
+			list.push(address);
+			buckets.set(bucketKey, list);
+		}
+		const response = { chain_id };
+		for (const [type, list] of buckets.entries()) response[type] = list;
+		if (!response.not_supported) response.not_supported = [];
+		return response;
+	});
+}
+
 //#endregion
 //#region src/gatekeeper/Service.ts
 /**
@@ -4516,28 +5067,59 @@ async function validateOffers(body, gatekeeper) {
 * @param parameters - App parameters including the {@link Gatekeeper} instance.
 * @returns Hono app exposing gatekeeper endpoints.
 */
+const CallbackTypesRequestSchema = z$2.object({ callbacks: z$2.array(z$2.object({
+	chain_id: z$2.number(),
+	addresses: z$2.array(z$2.string().regex(/^0x[a-fA-F0-9]{40}$/))
+})) });
 function createApp(parameters) {
-	const { gatekeeper } = parameters;
+	const { gatekeeper, chainRegistry } = parameters;
 	const app = new Hono();
 	app.post("/v1/validate", async (c) => {
 		let body;
 		try {
 			body = await c.req.json();
 		} catch (err) {
-			const failure$3 = failure(err);
-			return c.json(failure$3.body, failure$3.statusCode);
+			const failure$5 = failure(err);
+			return c.json(failure$5.body, failure$5.statusCode);
 		}
 		if (body === null || typeof body !== "object") {
-			const failure$2 = failure(new BadRequestError("Request body must be a JSON object"));
-			return c.json(failure$2.body, failure$2.statusCode);
+			const failure$9 = failure(new BadRequestError("Request body must be a JSON object"));
+			return c.json(failure$9.body, failure$9.statusCode);
 		}
 		const { statusCode, body: payload } = await validateOffers(body, gatekeeper);
 		return c.json(payload, statusCode);
 	});
-	app.get("/v1/rules", async (c) => {
-		const rules = await gatekeeper.getRules();
-		const response = success({ data: rules });
-		return c.json(response.body, response.statusCode);
+	app.get("/v1/config/rules", async (c) => {
+		const { statusCode, body } = await getConfigRules(c.req.query(), chainRegistry.list());
+		return c.json(body, statusCode);
+	});
+	app.post("/v1/callbacks", async (c) => {
+		let body;
+		try {
+			body = await c.req.json();
+		} catch (err) {
+			const failure$8 = failure(err);
+			return c.json(failure$8.body, failure$8.statusCode);
+		}
+		if (body === null || typeof body !== "object") {
+			const failure$6 = failure(new BadRequestError("Request body must be a JSON object"));
+			return c.json(failure$6.body, failure$6.statusCode);
+		}
+		try {
+			const request = CallbackTypesRequestSchema.parse(body);
+			const chainIds = new Set(chainRegistry.list().map((chain) => chain.id));
+			const unknown = request.callbacks.find((entry) => !chainIds.has(entry.chain_id));
+			if (unknown) throw new BadRequestError(`Unknown chain id ${unknown.chain_id}`);
+			const data = resolveCallbackTypes$2({
+				chains: chainRegistry.list(),
+				request
+			});
+			const response = success({ data });
+			return c.json(response.body, response.statusCode);
+		} catch (err) {
+			const failure$7 = failure(err);
+			return c.json(failure$7.body, failure$7.statusCode);
+		}
 	});
 	return app;
 }
@@ -4547,8 +5129,11 @@ function createApp(parameters) {
 * @returns Service handle including base URL and shutdown method. {@link ServiceHandle}
 */
 async function start$1(config) {
-	const { gatekeeper, port, hostname } = config;
-	const app = createApp({ gatekeeper });
+	const { gatekeeper, chainRegistry, port, hostname } = config;
+	const app = createApp({
+		gatekeeper,
+		chainRegistry
+	});
 	let address = null;
 	let server;
 	await new Promise((resolve) => {
@@ -4748,6 +5333,18 @@ async function* collectOffersV2(parameters) {
 	const logger = getLogger();
 	let startBlock = blockNumber;
 	let reorgDetected = false;
+	if (client.chain.custom.morpho.address.toLowerCase() === zeroAddress) {
+		const msg = "Morpho V2 address is zero, signature verification will fail. Please set the Morpho V2 address in the chain configuration.";
+		logger.error({
+			msg,
+			chain_id: client.chain.id
+		});
+		throw new Error(msg);
+	}
+	const signatureDomain = {
+		chainId: client.chain.id,
+		verifyingContract: client.chain.custom.morpho.address
+	};
 	const { blockNumber: latestBlockNumberChain } = await db.blocks.getChain(client.chain.id);
 	const stream = streamLogs({
 		client,
@@ -4778,7 +5375,7 @@ async function* collectOffersV2(parameters) {
 			if (!log) continue;
 			const [payload] = decodeAbiParameters([{ type: "bytes" }], log.data);
 			try {
-				const { tree, signature, signer } = await decode(payload);
+				const { tree, signature, signer } = await decode(payload, signatureDomain);
 				const signerMismatch = tree.offers.find((offer) => offer.maker.toLowerCase() !== signer.toLowerCase());
 				if (signerMismatch) {
 					logger.debug({
@@ -4810,6 +5407,7 @@ async function* collectOffersV2(parameters) {
 			const { epoch, blockNumber: latestBlockNumber } = await dbTx.blocks.getChain(client.chain.id);
 			const treesToInsert = [];
 			let totalValidOffers = 0;
+			const offersWithBlock = [];
 			for (const { tree, signature, blockNumber: treeBlockNumber } of decodedTrees) try {
 				const allowedResults = await gatekeeper.isAllowed(tree.offers);
 				const hasBlockWindowViolation = treeBlockNumber > latestBlockNumber;
@@ -4831,10 +5429,13 @@ async function* collectOffersV2(parameters) {
 				}
 				treesToInsert.push({
 					tree,
-					signature,
-					blockNumber: treeBlockNumber
+					signature
 				});
 				totalValidOffers += tree.offers.length;
+				offersWithBlock.push(...tree.offers.map((offer) => ({
+					offer,
+					blockNumber: treeBlockNumber
+				})));
 			} catch (err) {
 				const error = err instanceof Error ? err : new Error(String(err));
 				logger.error({
@@ -4844,7 +5445,24 @@ async function* collectOffersV2(parameters) {
 				});
 				throw new Error("Gatekeeper validation failed", { cause: error });
 			}
+			const dependencies = buildOfferDependencies$1(offersWithBlock);
+			await dbTx.oracles.upsert(dependencies.oracles);
+			await dbTx.obligations.create(dependencies.obligations);
+			await dbTx.groups.create(dependencies.groups);
+			const insertedHashes = await dbTx.offers.create(dependencies.offerBatches);
 			if (treesToInsert.length > 0) await dbTx.trees.create(treesToInsert);
+			const insertedOffers = filterInsertedOffers({
+				offers: offersWithBlock,
+				hashes: insertedHashes
+			});
+			const { callbacks, positions, lots } = await decodeCallbacks({
+				chainId: client.chain.id,
+				gatekeeper,
+				offers: insertedOffers
+			});
+			if (positions.length > 0) await dbTx.positions.upsert(positions);
+			if (callbacks.length > 0) await dbTx.callbacks.upsert(callbacks);
+			if (lots.length > 0) await dbTx.lots.create(lots);
 			try {
 				await dbTx.blocks.advanceCollector({
 					collectorName: collector,
@@ -4897,10 +5515,151 @@ async function* collectOffersV2(parameters) {
 				}
 			}
 		});
-		if (reorgDetected) return;
-		yield blockNumber;
-		startBlock = blockNumber;
+		if (reorgDetected) return;
+		yield blockNumber;
+		startBlock = blockNumber;
+	}
+}
+async function decodeCallbacks(parameters) {
+	const { chainId, gatekeeper, offers } = parameters;
+	if (offers.length === 0) return {
+		callbacks: [],
+		positions: [],
+		lots: []
+	};
+	const addresses = offers.filter((entry) => entry.offer.callback.data !== "0x").map((entry) => entry.offer.callback.address);
+	if (addresses.length === 0) return {
+		callbacks: [],
+		positions: [],
+		lots: []
+	};
+	let response;
+	try {
+		response = await gatekeeper.getCallbackTypes({ callbacks: [{
+			chain_id: chainId,
+			addresses
+		}] });
+	} catch (err) {
+		const error = err instanceof Error ? err : new Error(String(err));
+		throw new Error("Failed to resolve callback types", { cause: error });
+	}
+	const entry = response.find((item) => item.chain_id === chainId);
+	const typeByAddress = /* @__PURE__ */ new Map();
+	if (entry) for (const [key, list] of Object.entries(entry)) {
+		if (key === "chain_id" || key === "not_supported") continue;
+		if (!Array.isArray(list)) continue;
+		for (const address of list) typeByAddress.set(address.toLowerCase(), key);
+	}
+	const callbacks = [];
+	const positions = [];
+	const lots = [];
+	for (const { offer, blockNumber: offerBlockNumber } of offers) {
+		if (offer.callback.data === "0x") continue;
+		const callbackType = typeByAddress.get(offer.callback.address.toLowerCase());
+		if (!callbackType) continue;
+		let decoded;
+		try {
+			decoded = decode$1(callbackType, offer.callback.data);
+		} catch (err) {
+			const error = err instanceof Error ? err : new Error(String(err));
+			throw new Error("Failed to decode callback data", { cause: error });
+		}
+		if (decoded.length === 0) continue;
+		const offerHash = hash(offer);
+		const callbackInputs = decoded.map((callback) => ({
+			chainId: offer.chainId,
+			contract: callback.contract,
+			user: offer.maker,
+			amount: callback.amount
+		}));
+		callbacks.push({
+			offerHash,
+			callbacks: callbackInputs
+		});
+		for (const callback of decoded) {
+			const contract = callback.contract;
+			const positionType = callbackType === Type$1.BuyVaultV1Callback ? Type.VAULT_V1 : Type.ERC20;
+			const asset = callbackType === Type$1.BuyVaultV1Callback ? void 0 : contract;
+			positions.push(from$10({
+				chainId: offer.chainId,
+				contract,
+				user: offer.maker,
+				type: positionType,
+				asset,
+				blockNumber: offerBlockNumber
+			}));
+			const isLoanPosition = offer.loanToken.toLowerCase() === asset?.toLowerCase();
+			lots.push({
+				positionChainId: offer.chainId,
+				positionContract: contract,
+				positionUser: offer.maker,
+				group: offer.group,
+				size: isLoanPosition ? offer.assets : callback.amount
+			});
+		}
+	}
+	return {
+		callbacks,
+		positions,
+		lots
+	};
+}
+function buildOfferDependencies$1(offers) {
+	const obligationsById = /* @__PURE__ */ new Map();
+	const oraclesByKey = /* @__PURE__ */ new Map();
+	const groupsByKey = /* @__PURE__ */ new Map();
+	const offersByBlock = /* @__PURE__ */ new Map();
+	for (const { offer, blockNumber } of offers) {
+		const list = offersByBlock.get(blockNumber) ?? [];
+		list.push(offer);
+		offersByBlock.set(blockNumber, list);
+		const obligationId$2 = obligationId(offer);
+		if (!obligationsById.get(obligationId$2)) obligationsById.set(obligationId$2, from$13({
+			chainId: offer.chainId,
+			loanToken: offer.loanToken,
+			maturity: offer.maturity,
+			collaterals: offer.collaterals
+		}));
+		for (const collateral of offer.collaterals) {
+			const oracleKey = `${offer.chainId}-${collateral.oracle}`.toLowerCase();
+			if (!oraclesByKey.has(oracleKey)) oraclesByKey.set(oracleKey, from$11({
+				chainId: offer.chainId,
+				address: collateral.oracle,
+				price: null,
+				blockNumber
+			}));
+		}
+		const groupKey = `${offer.chainId}-${offer.maker}-${offer.group}`.toLowerCase();
+		if (!groupsByKey.has(groupKey)) groupsByKey.set(groupKey, {
+			chainId: offer.chainId,
+			maker: offer.maker,
+			group: offer.group,
+			blockNumber
+		});
+	}
+	return {
+		obligations: Array.from(obligationsById.values()),
+		oracles: Array.from(oraclesByKey.values()),
+		groups: Array.from(groupsByKey.values()),
+		offerBatches: Array.from(offersByBlock.entries()).map(([blockNumber, items]) => ({
+			blockNumber,
+			offers: items
+		}))
+	};
+}
+function filterInsertedOffers(parameters) {
+	if (parameters.hashes.length === 0) return [];
+	const inserted = new Set(parameters.hashes.map((hash) => hash.toLowerCase()));
+	const seen = /* @__PURE__ */ new Set();
+	const filtered = [];
+	for (const entry of parameters.offers) {
+		const hash$2 = hash(entry.offer).toLowerCase();
+		if (!inserted.has(hash$2)) continue;
+		if (seen.has(hash$2)) continue;
+		seen.add(hash$2);
+		filtered.push(entry);
 	}
+	return filtered;
 }
 
 //#endregion
@@ -5160,7 +5919,7 @@ async function* collectPositions(parameters) {
 				});
 				continue;
 			}
-			transfers.push(from$7({
+			transfers.push(from$8({
 				id: `${client.chain.id}-${log.blockNumber.toString()}-${log.transactionHash}-${log.logIndex.toString()}`,
 				chainId: client.chain.id,
 				contract: log.address,
@@ -5499,7 +6258,7 @@ async function* collectPrices(parameters) {
 //#region src/indexer/collectors/CollectorBuilder.ts
 function createBuilder(parameters) {
 	const { client, db, gatekeeper, options: { maxBlockNumber, blockWindow, interval } = {} } = parameters;
-	const createCollector = (name, collect) => create$13({
+	const createCollector = (name, collect) => create$16({
 		name,
 		collect,
 		client,
@@ -5603,7 +6362,7 @@ function from$1(config) {
 		retryAttempts,
 		retryDelayMs
 	});
-	return create$15({
+	return create$18({
 		client,
 		collectors: [
 			offersCollector,
@@ -5613,7 +6372,7 @@ function from$1(config) {
 		]
 	});
 }
-function create$15(params) {
+function create$18(params) {
 	const { collectors, client } = params;
 	const indexerId = `${client.chain.id.toString()}.indexer`;
 	const tracer = getTracer(`router.${indexerId}`);
@@ -5642,7 +6401,7 @@ function create$15(params) {
 
 //#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;
@@ -5882,8 +6641,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
@@ -6119,7 +6878,6 @@ const obligationCollateralsV2 = s.table(EnumTableName.OBLIGATION_COLLATERALS_V2,
 	oracleChainId: bigint("oracle_chain_id", { mode: "number" }).$type().notNull(),
 	oracleAddress: varchar("oracle_address", { length: 42 }).notNull(),
 	lltv: bigint("lltv", { mode: "bigint" }).notNull(),
-	blockNumber: bigint("block_number", { mode: "number" }).notNull(),
 	updatedAt: timestamp("updated_at").defaultNow().notNull()
 }, (table) => [
 	primaryKey({
@@ -6415,7 +7173,7 @@ const merklePaths = s.table(EnumTableName.MERKLE_PATHS, {
 //#endregion
 //#region src/database/domains/Blocks.ts
 /** Postgres implementation. */
-const create$12 = (config) => {
+const create$15 = (config) => {
 	const { db, chainRegistry } = config;
 	const getChain = async (chainId) => {
 		const rows = await db.select({
@@ -6596,7 +7354,7 @@ const create$12 = (config) => {
 //#region src/database/domains/Book.ts
 const DEFAULT_LIMIT$3 = 100;
 const MAX_TOTAL_OFFERS = 500;
-function create$11(config) {
+function create$14(config) {
 	const db = config.db;
 	const logger = getLogger();
 	const getOffers = async (parameters) => {
@@ -7060,16 +7818,76 @@ let LevelCursor;
 */
 const DEFAULT_BATCH_SIZE = 4e3;
 
+//#endregion
+//#region src/database/domains/Callbacks.ts
+/**
+* Create a callbacks domain instance.
+* @param db - Database core instance.
+* @returns Callbacks domain. {@link CallbacksDomain}
+*/
+function create$13(db) {
+	return {
+		upsert: async (inputs) => {
+			if (inputs.length === 0) return;
+			const idCache = /* @__PURE__ */ new Map();
+			const seenCallbackIds = /* @__PURE__ */ new Set();
+			const callbacksRows = [];
+			const offersCallbacksRows = [];
+			const callbackId = (input) => {
+				const preimage = `0x${input.chainId}${input.contract}${input.user}${input.amount.toString()}`.toLowerCase();
+				const id = idCache.get(preimage) ?? keccak256(preimage);
+				idCache.set(preimage, id);
+				return id;
+			};
+			for (const { offerHash, callbacks } of inputs) {
+				const normalizedOfferHash = offerHash.toLowerCase();
+				for (const callback of callbacks) {
+					const normalized = {
+						chainId: callback.chainId,
+						contract: callback.contract.toLowerCase(),
+						user: callback.user.toLowerCase(),
+						amount: callback.amount
+					};
+					const id = callbackId(normalized);
+					offersCallbacksRows.push({
+						offerHash: normalizedOfferHash,
+						callbackId: id
+					});
+					if (seenCallbackIds.has(id)) continue;
+					seenCallbackIds.add(id);
+					callbacksRows.push({
+						id,
+						positionChainId: normalized.chainId,
+						positionContract: normalized.contract,
+						positionUser: normalized.user,
+						amount: normalized.amount.toString()
+					});
+				}
+			}
+			if (offersCallbacksRows.length === 0) return;
+			await db.transaction(async (dbTx) => {
+				for (const batch of batch$1(callbacksRows, DEFAULT_BATCH_SIZE)) await dbTx.insert(callbacks).values(batch).onConflictDoNothing();
+				for (const batch of batch$1(offersCallbacksRows, DEFAULT_BATCH_SIZE)) await dbTx.insert(offersCallbacks).values(batch).onConflictDoNothing();
+			});
+		},
+		delete: async ({ offers }) => {
+			if (offers.length === 0) return 0;
+			const normalized = offers.map((offer) => offer.toLowerCase());
+			return (await db.delete(offersCallbacks).where(inArray(offersCallbacks.offerHash, normalized))).affectedRows;
+		}
+	};
+}
+
 //#endregion
 //#region src/database/domains/Consumed.ts
-function create$10(db) {
+function create$12(db) {
 	return {
 		create: async (events) => {
 			if (events.length === 0) return;
-			const groups$1 = /* @__PURE__ */ new Map();
+			const groups$2 = /* @__PURE__ */ new Map();
 			for (const event of events) {
 				const groupId = `${event.chainId}-${event.maker}-${event.group}`.toLowerCase();
-				groups$1.set(groupId, {
+				groups$2.set(groupId, {
 					chainId: event.chainId,
 					maker: event.maker,
 					group: event.group,
@@ -7077,7 +7895,7 @@ function create$10(db) {
 				});
 			}
 			await db.transaction(async (dbTx) => {
-				const groupsRows = Array.from(groups$1.values()).map((group) => ({
+				const groupsRows = Array.from(groups$2.values()).map((group) => ({
 					chainId: group.chainId,
 					maker: group.maker.toLowerCase(),
 					group: group.group.toLowerCase(),
@@ -7103,9 +7921,30 @@ function create$10(db) {
 	};
 }
 
+//#endregion
+//#region src/database/domains/Groups.ts
+/**
+* Create a groups domain instance.
+* @param db - Database core instance.
+* @returns Groups domain. {@link GroupsDomain}
+*/
+function create$11(db) {
+	return { create: async (groups$1) => {
+		if (groups$1.length === 0) return;
+		const rows = groups$1.map((group) => ({
+			chainId: group.chainId,
+			maker: group.maker.toLowerCase(),
+			group: group.group.toLowerCase(),
+			consumed: (group.consumed ?? 0n).toString(),
+			blockNumber: group.blockNumber
+		}));
+		for (const batch of batch$1(rows, DEFAULT_BATCH_SIZE)) await db.insert(groups).values(batch).onConflictDoNothing();
+	} };
+}
+
 //#endregion
 //#region src/database/domains/Lots.ts
-function create$9(db) {
+function create$10(db) {
 	return {
 		get: async (parameters) => {
 			const { chainId, user, contract, group } = parameters ?? {};
@@ -7149,268 +7988,88 @@ function create$9(db) {
 }
 
 //#endregion
-//#region src/gatekeeper/Client.ts
-const DEFAULT_TIMEOUT_MS = 1e4;
+//#region src/database/domains/Obligations.ts
 /**
-* Create an HTTP client for a gatekeeper service.
-* @param config - Gatekeeper client configuration. {@link ClientConfig}
-* @returns An HTTP-backed gatekeeper client. {@link GatekeeperClient}
+* Create an obligations domain instance.
+* @param db - Database core instance.
+* @returns Obligations domain. {@link ObligationsDomain}
 */
-function createHttpClient(config) {
-	const fetchFn = config.fetchFn ?? fetch;
-	const timeoutMs = config.timeoutMs ?? DEFAULT_TIMEOUT_MS;
-	const baseUrl = normalizeBaseUrl(config.baseUrl);
-	const request = async (path, init) => {
-		const controller = new AbortController();
-		const timeout = setTimeout(() => controller.abort(), timeoutMs);
+function create$9(db) {
+	return { create: async (obligations$1) => {
+		if (obligations$1.length === 0) return;
+		const obligationsById = /* @__PURE__ */ new Map();
+		for (const obligation of obligations$1) {
+			const id$1 = id(obligation).toLowerCase();
+			if (!obligationsById.get(id$1)) obligationsById.set(id$1, obligation);
+		}
 		try {
-			return await fetchFn(`${baseUrl}${path}`, {
-				...init,
-				signal: controller.signal
+			await db.transaction(async (dbTx) => {
+				const obligationRows = obligations$1.map((obligation) => ({
+					obligationId: id(obligation),
+					chainId: obligation.chainId,
+					loanToken: obligation.loanToken.toLowerCase(),
+					maturity: obligation.maturity
+				}));
+				for (const batch of batch$1(obligationRows, DEFAULT_BATCH_SIZE)) await dbTx.insert(obligations).values(batch).onConflictDoNothing();
+				const collateralRows = obligations$1.flatMap((obligation) => {
+					return obligation.collaterals.map((collateral) => ({
+						obligationId: id(obligation),
+						asset: collateral.asset.toLowerCase(),
+						oracleChainId: obligation.chainId,
+						oracleAddress: collateral.oracle.toLowerCase(),
+						lltv: collateral.lltv
+					}));
+				});
+				for (const batch of batch$1(collateralRows, DEFAULT_BATCH_SIZE)) await dbTx.insert(obligationCollateralsV2).values(batch).onConflictDoNothing();
 			});
-		} finally {
-			clearTimeout(timeout);
-		}
-	};
-	const validate = async (body) => {
-		const response = await request("/v1/validate", {
-			method: "POST",
-			headers: { "content-type": "application/json" },
-			body: JSON.stringify(body)
-		});
-		const json = await response.json();
-		return {
-			statusCode: response.status,
-			body: json
-		};
-	};
-	const getRules = async () => {
-		const response = await request("/v1/rules", { method: "GET" });
-		const json = await response.json();
-		if (!response.ok) throw new Error(`Gatekeeper rules request failed: ${extractErrorMessage(json) ?? response.statusText}`);
-		if (!("data" in json) || !Array.isArray(json.data)) throw new Error("Gatekeeper rules response is invalid.");
-		return json.data;
-	};
-	const isAllowed = async (offers) => {
-		const { statusCode, body } = await validate({ offers: offers.map((offer) => toSnakeCase(offer)) });
-		if (statusCode !== 200) {
-			const errorMessage = extractErrorMessage(body);
-			throw new Error(`Gatekeeper validation failed: ${errorMessage ?? `status ${statusCode}`}`);
-		}
-		const data = body.data;
-		if (!data || typeof data !== "object") throw new Error("Gatekeeper validation response is invalid.");
-		if ("issues" in data) {
-			const issues = data.issues.map((issue) => ({
-				ruleName: issue.rule,
-				message: issue.message,
-				item: offers[issue.index]
-			}));
-			const invalidIndices = new Set(data.issues.map((issue) => issue.index));
-			return {
-				valid: offers.filter((_, index) => !invalidIndices.has(index)),
-				issues
-			};
+		} catch (err) {
+			const error = err instanceof Error ? err : new Error(String(err));
+			throw new Error("Obligations.create failed. Ensure oracles exist before inserting obligations.", { cause: error });
 		}
-		if (!("payload" in data) || !("root" in data)) throw new Error("Gatekeeper validation response is missing payload data.");
-		return {
-			valid: offers.slice(),
-			issues: []
-		};
-	};
-	return {
-		baseUrl,
-		validate,
-		isAllowed,
-		getRules
-	};
-}
-function normalizeBaseUrl(url) {
-	return url.trim().replace(/\/+$/, "");
-}
-function extractErrorMessage(payload) {
-	if (!payload || typeof payload !== "object") return void 0;
-	const error = payload.error;
-	if (!error || typeof error !== "object") return void 0;
-	return typeof error.message === "string" ? error.message : void 0;
+	} };
 }
 
 //#endregion
 //#region src/database/domains/Offers.ts
 const DEFAULT_LIMIT$2 = 100;
 function create$8(config) {
-	const { db, chainRegistry } = config;
+	const { db } = config;
 	return {
 		create: async (batches) => {
 			if (batches.length === 0) return [];
-			const offersWithBlock = batches.flatMap(({ blockNumber, offers }) => offers.map((offer) => ({
-				offer,
+			const offersRows = batches.flatMap(({ blockNumber, offers }) => offers.map((offer) => ({
+				...serialize(offer),
+				obligationId: obligationId(offer),
+				groupChainId: offer.chainId,
+				groupMaker: offer.maker.toLowerCase(),
+				callbackAddress: offer.callback.address.toLowerCase(),
+				callbackData: offer.callback.data,
 				blockNumber
 			})));
-			if (offersWithBlock.length === 0) return [];
-			const obligationsMap = /* @__PURE__ */ new Map();
-			const collateralsMap = /* @__PURE__ */ new Map();
-			const oraclesMap = /* @__PURE__ */ new Map();
-			const groupsMap = /* @__PURE__ */ new Map();
-			for (const { offer, blockNumber } of offersWithBlock) {
-				const obligationId$1 = obligationId(offer);
-				if (!obligationsMap.has(obligationId$1)) {
-					obligationsMap.set(obligationId$1, from$13({
-						chainId: offer.chainId,
-						loanToken: offer.loanToken,
-						maturity: offer.maturity,
-						collaterals: offer.collaterals
-					}));
-					collateralsMap.set(obligationId$1, {
-						collaterals: [...offer.collaterals],
-						blockNumber
-					});
-					for (const collateral of offer.collaterals) {
-						const oracleId = `${offer.chainId}-${collateral.oracle.toLowerCase()}`.toLowerCase();
-						if (!oraclesMap.has(oracleId)) oraclesMap.set(oracleId, {
-							chainId: offer.chainId,
-							address: collateral.oracle,
-							blockNumber
-						});
+			if (offersRows.length === 0) return [];
+			try {
+				return await db.transaction(async (dbTx) => {
+					const selectExisting = async (hashes) => {
+						if (hashes.length === 0) return /* @__PURE__ */ new Set();
+						const existing = /* @__PURE__ */ new Set();
+						for (const batch of batch$1(hashes, DEFAULT_BATCH_SIZE)) {
+							const rows = await dbTx.select({ hash: offers.hash }).from(offers).where(inArray(offers.hash, batch));
+							for (const row of rows) existing.add(String(row.hash).toLowerCase());
+						}
+						return existing;
+					};
+					const inserted = [];
+					for (const batch of batch$1(offersRows, DEFAULT_BATCH_SIZE)) {
+						const rows = await dbTx.insert(offers).values(batch).onConflictDoNothing().returning();
+						inserted.push(...rows.map((row) => row.hash));
 					}
-				}
-				const groupId = `${offer.chainId}-${offer.maker}-${offer.group}`.toLowerCase();
-				if (!groupsMap.has(groupId)) groupsMap.set(groupId, {
-					chainId: offer.chainId,
-					maker: offer.maker,
-					group: offer.group,
-					blockNumber
+					const existing = await selectExisting(inserted);
+					return inserted.filter((hash) => existing.has(hash));
 				});
+			} catch (err) {
+				const error = err instanceof Error ? err : new Error(String(err));
+				throw new Error("Offers.create failed. Ensure obligations and groups exist before inserting offers.", { cause: error });
 			}
-			return await db.transaction(async (dbTx) => {
-				const obligationsRows = Array.from(obligationsMap.entries()).map(([obligationId, obligation]) => ({
-					obligationId,
-					chainId: obligation.chainId,
-					loanToken: obligation.loanToken.toLowerCase(),
-					maturity: obligation.maturity
-				}));
-				for (const batch of batch$1(obligationsRows, DEFAULT_BATCH_SIZE)) await dbTx.insert(obligations).values(batch).onConflictDoNothing();
-				const oraclesRows = Array.from(oraclesMap.values()).map((oracle) => ({
-					chainId: oracle.chainId,
-					address: oracle.address.toLowerCase(),
-					blockNumber: oracle.blockNumber
-				}));
-				for (const batch of batch$1(oraclesRows, DEFAULT_BATCH_SIZE)) await dbTx.insert(oracles).values(batch).onConflictDoNothing();
-				const collateralsRows = Array.from(collateralsMap.entries()).flatMap(([obligationId, items]) => items.collaterals.map((collateral) => ({
-					obligationId,
-					asset: collateral.asset.toLowerCase(),
-					oracleChainId: obligationsMap.get(obligationId).chainId,
-					oracleAddress: collateral.oracle.toLowerCase(),
-					lltv: collateral.lltv,
-					blockNumber: items.blockNumber
-				})));
-				for (const batch of batch$1(collateralsRows, DEFAULT_BATCH_SIZE)) await dbTx.insert(obligationCollateralsV2).values(batch).onConflictDoNothing();
-				const groupsRows = Array.from(groupsMap.values()).map((group) => ({
-					chainId: group.chainId,
-					maker: group.maker.toLowerCase(),
-					group: group.group.toLowerCase(),
-					consumed: "0",
-					blockNumber: group.blockNumber
-				}));
-				for (const batch of batch$1(groupsRows, DEFAULT_BATCH_SIZE)) await dbTx.insert(groups).values(batch).onConflictDoNothing();
-				const offersRows = offersWithBlock.map(({ offer, blockNumber }) => ({
-					...serialize(offer),
-					obligationId: obligationId(offer),
-					groupChainId: offer.chainId,
-					groupMaker: offer.maker.toLowerCase(),
-					callbackAddress: offer.callback.address.toLowerCase(),
-					callbackData: offer.callback.data,
-					blockNumber
-				}));
-				const inserted = [];
-				for (const batch of batch$1(offersRows, DEFAULT_BATCH_SIZE)) {
-					const result = await dbTx.insert(offers).values(batch).onConflictDoNothing().returning();
-					inserted.push(...result);
-				}
-				if (inserted.length === 0) return [];
-				const idCached = /* @__PURE__ */ new Map();
-				const id = (params) => {
-					const preimage = `0x${params.chainId}${params.contract}${params.user}${params.amount}`.toLowerCase();
-					const id = idCached.get(preimage) ?? keccak256(preimage);
-					idCached.set(preimage, id);
-					return id;
-				};
-				const offersCallbacksMap = /* @__PURE__ */ new Map();
-				for (const offer of inserted) {
-					if (offer.callbackData === "0x") continue;
-					const user = offer.groupMaker.toLowerCase();
-					if (!offersCallbacksMap.has(offer.hash)) offersCallbacksMap.set(offer.hash, []);
-					const chain = chainRegistry.getById(offer.groupChainId);
-					if (!chain) continue;
-					const callbackType = getCallbackType(chain.name, offer.callbackAddress);
-					if (!callbackType) continue;
-					const callbacks = decode$1(callbackType, offer.callbackData).map((callback) => ({
-						chainId: offer.groupChainId,
-						contract: callback.contract.toLowerCase(),
-						user: user.toLowerCase(),
-						amount: callback.amount.toString(),
-						type: callbackType === Type$1.BuyVaultV1Callback ? Type.VAULT_V1 : Type.ERC20,
-						asset: callbackType === Type$1.BuyVaultV1Callback ? void 0 : callback.contract.toLowerCase(),
-						blockNumber: offer.blockNumber
-					}));
-					try {
-						await dbTx.insert(offersCallbacks).values(callbacks.map((callback) => ({
-							offerHash: offer.hash,
-							callbackId: id(callback)
-						}))).onConflictDoNothing();
-						offersCallbacksMap.get(offer.hash).push(...callbacks);
-					} catch (_) {
-						offersCallbacksMap.delete(offer.hash);
-					}
-				}
-				if (offersCallbacksMap.size === 0) {
-					obligationsMap.clear();
-					collateralsMap.clear();
-					oraclesMap.clear();
-					groupsMap.clear();
-					offersCallbacksMap.clear();
-					idCached.clear();
-					return inserted.map((offer) => offer.hash);
-				}
-				await dbTx.positions.upsert(Array.from(offersCallbacksMap.values()).flatMap((callbacks) => callbacks.map((callback) => ({
-					chainId: callback.chainId,
-					contract: callback.contract,
-					user: callback.user,
-					type: callback.type,
-					asset: callback.asset,
-					blockNumber: callback.blockNumber
-				}))));
-				const callbacksRows = Array.from(offersCallbacksMap.values()).flatMap((callbacks) => callbacks.map((callback) => ({
-					id: id(callback),
-					positionChainId: callback.chainId,
-					positionContract: callback.contract,
-					positionUser: callback.user,
-					amount: callback.amount
-				})));
-				for (const batch of batch$1(callbacksRows, DEFAULT_BATCH_SIZE)) await dbTx.insert(callbacks).values(batch).onConflictDoNothing();
-				const lotInfos = [];
-				for (const [offerHash, callbacks] of offersCallbacksMap.entries()) {
-					const offer = inserted.find((o) => o.hash === offerHash);
-					if (!offer) continue;
-					for (const callback of callbacks) {
-						const isLoanPosition = obligationsMap.get(offer.obligationId)?.loanToken.toLowerCase() === callback.asset?.toLowerCase();
-						lotInfos.push({
-							positionChainId: callback.chainId,
-							positionContract: callback.contract,
-							positionUser: callback.user,
-							group: offer.group,
-							size: isLoanPosition ? BigInt(offer.assets) : BigInt(callback.amount)
-						});
-					}
-				}
-				if (lotInfos.length > 0) await dbTx.lots.create(lotInfos);
-				obligationsMap.clear();
-				collateralsMap.clear();
-				oraclesMap.clear();
-				groupsMap.clear();
-				offersCallbacksMap.clear();
-				idCached.clear();
-				return inserted.map((offer) => offer.hash);
-			});
 		},
 		get: async (parameters) => {
 			const limit = parameters?.limit ?? DEFAULT_LIMIT$2;
@@ -7430,36 +8089,12 @@ function create$8(config) {
         '[]'::jsonb
       )`.as("collaterals") }).from(obligationCollateralsV2).innerJoin(oracles, sql`${obligationCollateralsV2.oracleChainId} = ${oracles.chainId}
              AND ${obligationCollateralsV2.oracleAddress} = ${oracles.address}`).where(eq(obligationCollateralsV2.obligationId, offers.obligationId)).as("collaterals_lateral");
-			const availableLateral = db.select({ available: sql`COALESCE(SUM(
-            CASE
-              -- If asset is null, position available is 0
-              WHEN ${positions.asset} IS NULL THEN 0
-
-              -- Position asset matches loan token: no conversion needed
-              WHEN ${positions.asset} = ${obligations.loanToken} THEN
-                CASE
-                  WHEN ${callbacks.amount} IS NULL THEN COALESCE(${positions.balance}, 0)::numeric
-                  ELSE LEAST(${callbacks.amount}::numeric, COALESCE(${positions.balance}, 0)::numeric)
-                END
-
-              -- Position asset is collateral: apply oracle price * lltv
-              -- Formula: balance * price / 1e36 * lltv / 1e18
-              ELSE
-                (CASE
-                  WHEN ${callbacks.amount} IS NULL THEN COALESCE(${positions.balance}, 0)::numeric
-                  ELSE LEAST(${callbacks.amount}::numeric, COALESCE(${positions.balance}, 0)::numeric)
-                END)
-                * COALESCE(${oracles.price}, 0)::numeric / 1e36
-                * COALESCE(${obligationCollateralsV2.lltv}, 0)::numeric / 1e18
-            END
-          ), 0)`.as("available") }).from(offersCallbacks).innerJoin(callbacks, eq(offersCallbacks.callbackId, callbacks.id)).innerJoin(positions, and(eq(callbacks.positionChainId, positions.chainId), eq(callbacks.positionContract, positions.contract), eq(callbacks.positionUser, positions.user))).leftJoin(obligationCollateralsV2, and(eq(obligationCollateralsV2.obligationId, offers.obligationId), eq(obligationCollateralsV2.asset, positions.asset))).leftJoin(oracles, and(eq(oracles.chainId, obligationCollateralsV2.oracleChainId), eq(oracles.address, obligationCollateralsV2.oracleAddress))).where(eq(offersCallbacks.offerHash, offers.hash)).as("available_lateral");
 			const rows = (await db.select({
 				hash: offers.hash,
 				maker: offers.groupMaker,
 				assets: offers.assets,
 				obligationUnits: offers.obligationUnits,
 				obligationShares: offers.obligationShares,
-				consumed: groups.consumed,
 				price: offers.price,
 				maturity: offers.maturity,
 				expiry: offers.expiry,
@@ -7472,19 +8107,8 @@ function create$8(config) {
 				callbackAddress: offers.callbackAddress,
 				callbackData: offers.callbackData,
 				collaterals: collateralsLateral.collaterals,
-				blockNumber: offers.blockNumber,
-				available: sql`COALESCE(${availableLateral.available}::numeric, 0)`.as("available"),
-				takeable: sql`FLOOR(GREATEST(
-            0,
-            LEAST(
-              ${offers.assets}::numeric - ${groups.consumed}::numeric,
-              COALESCE(${availableLateral.available}::numeric, 0)
-            )
-          ))`.as("takeable")
-			}).from(offers).innerJoin(obligations, eq(offers.obligationId, obligations.obligationId)).innerJoin(groups, and(eq(offers.groupChainId, groups.chainId), eq(offers.groupMaker, groups.maker), eq(offers.group, groups.group))).innerJoinLateral(collateralsLateral, sql`true`).leftJoinLateral(availableLateral, sql`true`).where(and(cursor !== null && cursor !== void 0 ? gt(offers.hash, cursor) : void 0, maker !== void 0 ? eq(offers.groupMaker, maker.toLowerCase()) : void 0, maker === void 0 ? sql`GREATEST(0, LEAST(
-                  ${offers.assets}::numeric - ${groups.consumed}::numeric,
-                  COALESCE(${availableLateral.available}::numeric, 0)
-                )) > 0` : void 0)).orderBy(asc(offers.hash)).limit(limit)).map((row) => {
+				blockNumber: offers.blockNumber
+			}).from(offers).innerJoin(obligations, eq(offers.obligationId, obligations.obligationId)).innerJoinLateral(collateralsLateral, sql`true`).where(and(cursor !== null && cursor !== void 0 ? gt(offers.hash, cursor) : void 0, maker !== void 0 ? eq(offers.groupMaker, maker.toLowerCase()) : void 0)).orderBy(asc(offers.hash)).limit(limit)).map((row) => {
 				return {
 					hash: row.hash,
 					maker: row.maker,
@@ -7509,13 +8133,9 @@ function create$8(config) {
 						address: row.callbackAddress,
 						data: row.callbackData
 					},
-					state: {
-						hash: row.hash,
-						blockNumber: row.blockNumber
-					},
-					consumed: BigInt(row.consumed),
-					available: BigInt(String(row.available ?? "0").split(".")[0] ?? "0"),
-					takeable: BigInt(String(row.takeable ?? "0").split(".")[0] ?? "0"),
+					consumed: 0n,
+					available: 0n,
+					takeable: 0n,
 					blockNumber: row.blockNumber
 				};
 			});
@@ -7597,7 +8217,7 @@ function create$8(config) {
 				quote.bid = { price: BigInt(row.price) };
 			}
 			return Array.from(quotes.entries()).map(([id, quote]) => {
-				return from$8({
+				return from$9({
 					obligationId: id,
 					ask: quote.ask,
 					bid: quote.bid
@@ -7639,7 +8259,7 @@ function create$6(db) {
 				price: oracles.price,
 				blockNumber: oracles.blockNumber,
 				chainId: oracles.chainId
-			}).from(oracles).where(eq(oracles.chainId, chainId))).map((r) => from$10({
+			}).from(oracles).where(eq(oracles.chainId, chainId))).map((r) => from$11({
 				chainId: r.chainId,
 				address: r.address,
 				price: r.price,
@@ -7654,12 +8274,15 @@ function create$6(db) {
 				price: o.price !== null ? o.price.toString() : null,
 				blockNumber: o.blockNumber
 			}));
-			db.transaction(async (dbTx) => {
+			await db.transaction(async (dbTx) => {
 				for (const batch of batch$1(rows, DEFAULT_BATCH_SIZE)) await dbTx.insert(oracles).values(batch).onConflictDoUpdate({
 					target: [oracles.chainId, oracles.address],
 					set: {
-						price: sql`EXCLUDED.price`,
-						blockNumber: sql`EXCLUDED.block_number`,
+						price: sql`COALESCE(EXCLUDED.price, ${oracles.price})`,
+						blockNumber: sql`CASE
+                  WHEN EXCLUDED.price IS NULL THEN ${oracles.blockNumber}
+                  ELSE EXCLUDED.block_number
+                END`,
 						updatedAt: sql`NOW()`
 					}
 				});
@@ -8005,41 +8628,42 @@ function create$3(config) {
 	return {
 		create: async (trees$1) => {
 			if (trees$1.length === 0) return [];
-			return await db.transaction(async (dbTx) => {
-				const roots = [];
-				for (const { tree, signature, blockNumber } 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([{
-						blockNumber,
-						offers: tree.offers
-					}]);
-					const pathRows = proofs(tree).map((proof) => ({
-						offerHash: hash(proof.offer).toLowerCase(),
-						treeRoot: root,
-						proofNodes: concatenateProofs(proof.path)
-					}));
-					for (const batch of batch$1(pathRows, DEFAULT_BATCH_SIZE)) await dbTx.insert(merklePaths).values(batch).onConflictDoUpdate({
-						target: [merklePaths.offerHash],
-						set: {
-							treeRoot: sql`excluded.tree_root`,
-							proofNodes: sql`excluded.proof_nodes`,
-							createdAt: sql`NOW()`
-						}
-					});
-				}
-				return roots;
-			});
+			try {
+				return await db.transaction(async (dbTx) => {
+					const roots = [];
+					for (const { tree, signature } of trees$1) {
+						const root = tree.root.toLowerCase();
+						roots.push(root);
+						await dbTx.insert(trees).values({
+							root,
+							rootSignature: signature.toLowerCase()
+						}).onConflictDoUpdate({
+							target: [trees.root],
+							set: {
+								rootSignature: signature.toLowerCase(),
+								createdAt: sql`NOW()`
+							}
+						});
+						const pathRows = proofs(tree).map((proof) => ({
+							offerHash: hash(proof.offer).toLowerCase(),
+							treeRoot: root,
+							proofNodes: concatenateProofs(proof.path)
+						}));
+						for (const batch of batch$1(pathRows, DEFAULT_BATCH_SIZE)) await dbTx.insert(merklePaths).values(batch).onConflictDoUpdate({
+							target: [merklePaths.offerHash],
+							set: {
+								treeRoot: sql`excluded.tree_root`,
+								proofNodes: sql`excluded.proof_nodes`,
+								createdAt: sql`NOW()`
+							}
+						});
+					}
+					return roots;
+				});
+			} catch (err) {
+				const error = err instanceof Error ? err : new Error(String(err));
+				throw new Error("Trees.create failed. Ensure offers exist before inserting merkle paths.", { cause: error });
+			}
 		},
 		getAttestations: async (hashes) => {
 			if (hashes.length === 0) return /* @__PURE__ */ new Map();
@@ -8144,17 +8768,17 @@ function create$2(db) {
 //#region src/database/Database.ts
 function createDomains(core, chainRegistry) {
 	return {
-		book: create$11({ db: core }),
-		blocks: create$12({
-			db: core,
-			chainRegistry
-		}),
-		offers: create$8({
+		book: create$14({ db: core }),
+		blocks: create$15({
 			db: core,
 			chainRegistry
 		}),
-		consumed: create$10(core),
-		lots: create$9(core),
+		callbacks: create$13(core),
+		offers: create$8({ db: core }),
+		consumed: create$12(core),
+		groups: create$11(core),
+		lots: create$10(core),
+		obligations: create$9(core),
 		offsets: create$7(core),
 		oracles: create$6(core),
 		trees: create$3({ db: core }),
@@ -8183,6 +8807,10 @@ function augmentWithDomains(base, chainRegistry) {
 			value: dms.blocks,
 			enumerable: true
 		},
+		callbacks: {
+			value: dms.callbacks,
+			enumerable: true
+		},
 		offers: {
 			value: dms.offers,
 			enumerable: true
@@ -8191,10 +8819,18 @@ function augmentWithDomains(base, chainRegistry) {
 			value: dms.consumed,
 			enumerable: true
 		},
+		groups: {
+			value: dms.groups,
+			enumerable: true
+		},
 		lots: {
 			value: dms.lots,
 			enumerable: true
 		},
+		obligations: {
+			value: dms.obligations,
+			enumerable: true
+		},
 		offsets: {
 			value: dms.offsets,
 			enumerable: true
@@ -8636,6 +9272,8 @@ const ApiSchema = z.object({ port: z.number().int().positive() }).strict();
 const GatekeeperSchema = z.object({
 	url_env: z.string().min(1).optional(),
 	url: z.string().min(1).optional(),
+	origin_secret_env: z.string().min(1).optional(),
+	origin_secret: z.string().min(1).optional(),
 	timeout_ms: z.number().int().positive().optional(),
 	port: z.number().int().positive().optional()
 }).strict().optional();
@@ -8701,6 +9339,7 @@ function resolveRouterConfig(config, env) {
 		api: config.api ? { port: config.api.port } : void 0,
 		gatekeeper: {
 			url: resolveGatekeeperUrl(config.gatekeeper, env),
+			originSecret: resolveGatekeeperOriginSecret(config.gatekeeper, env),
 			timeoutMs: config.gatekeeper?.timeout_ms ?? 1e4,
 			port: config.gatekeeper?.port ?? 8082
 		},
@@ -8811,6 +9450,7 @@ function createDefaultConfig() {
 		api: { port: 8081 },
 		gatekeeper: {
 			url: void 0,
+			originSecret: void 0,
 			timeoutMs: 1e4,
 			port: 8082
 		},
@@ -8829,6 +9469,11 @@ function resolveGatekeeperUrl(gatekeeper, env) {
 	if (gatekeeper.url_env) return readEnvVar(env, gatekeeper.url_env, "Gatekeeper URL");
 	return gatekeeper.url;
 }
+function resolveGatekeeperOriginSecret(gatekeeper, env) {
+	if (!gatekeeper) return void 0;
+	if (gatekeeper.origin_secret_env) return readEnvVar(env, gatekeeper.origin_secret_env, "Gatekeeper origin secret");
+	return gatekeeper.origin_secret;
+}
 
 //#endregion
 //#region src/cli/commands/RouterCmd.ts
@@ -8851,7 +9496,7 @@ var RouterCmd = class RouterCmd extends Command {
 		const configPath = resolveConfigPath(options.configFile);
 		const config = configPath !== null ? loadRouterConfig(configPath) : createDefaultConfig();
 		const logger = defaultLogger(config.logging.level, config.logging.pretty);
-		const chainRegistry = create$16(Object.values(config.chains).map((entry) => entry.chain));
+		const chainRegistry = create$19(Object.values(config.chains).map((entry) => entry.chain));
 		const clients = (config.indexer?.chains ?? []).map((name) => {
 			const chainConfig = config.chains[name];
 			if (!chainConfig) throw new Error(`Indexer chain ${name} is not defined under [chains].`);
@@ -8899,9 +9544,10 @@ const gatekeeperCmd = new RouterCmd("gatekeeper");
 gatekeeperCmd.description("Start Gatekeeper validation service.").action(async (opts) => {
 	const { gatekeeper: gatekeeperConfig, chainRegistry, logger } = opts;
 	await runWithLogger(logger, async () => {
-		const gatekeeperCore = create$17({ rules: morphoRules(chainRegistry.list()) });
+		const gatekeeperCore = create$20({ rules: morphoRules(chainRegistry.list()) });
 		const handle = await start$1({
 			gatekeeper: gatekeeperCore,
+			chainRegistry,
 			port: gatekeeperConfig?.port ?? 8082
 		});
 		logger.info({
@@ -8952,23 +9598,99 @@ async function getBook(params, db) {
 		return failure(err);
 	}
 }
-
-//#endregion
-//#region src/api/Controllers/getConfig.ts
-/**
-* Returns the configuration for all chains the router is indexing.
-* @param chainRegistry - The chain registry instance. {@link ChainRegistry.ChainRegistry}
-* @returns The configuration for all chains the router is indexing. {@link ApiPayload.Payload<ChainConfig[]>}
-*/
-async function getConfig(chainRegistry) {
-	const configs = [];
-	for (const chain of chainRegistry.list()) configs.push({
-		chain_id: chain.id,
-		contracts: { mempool: chain.custom.mempool.address },
-		callbacks: chain.custom.callbacks.map((c) => c.type)
-	});
-	configs.sort((a, b) => a.chain_id - b.chain_id);
-	return success({ data: configs });
+
+//#endregion
+//#region src/api/Controllers/getConfigContracts.ts
+/**
+* Returns contract addresses used by indexers (mempool, v2) plus multicall per chain.
+* @param query - Raw query parameters containing optional chain filters.
+* @param chainRegistry - The chain registry instance. {@link ChainRegistry.ChainRegistry}
+* @returns The indexer contract configuration. {@link ApiPayload.Payload<ConfigContract[]>}
+*/
+async function getConfigContracts(query, chainRegistry) {
+	const parsed = safeParse("get_config_contracts", query ?? {});
+	if (!parsed.success) return failure(parsed.error);
+	const { chains: chainsFilter, cursor, limit } = parsed.data;
+	const chainFilter = chainsFilter?.length ? new Set(chainsFilter) : null;
+	const contracts = [];
+	const seenAddresses = /* @__PURE__ */ new Set();
+	for (const chain of chainRegistry.list()) {
+		if (chainFilter && !chainFilter.has(chain.id)) continue;
+		const mempool = chain.custom?.mempool?.address;
+		if (!mempool) return failure(new InternalServerError(`Missing mempool address for chain ${chain.id}.`));
+		const multicall = chain.contracts?.multicall3?.address;
+		if (!multicall) return failure(new InternalServerError(`Missing multicall3 address for chain ${chain.id}.`));
+		const v2 = chain.custom?.morpho?.address;
+		if (!v2) return failure(new InternalServerError(`Missing morpho address for chain ${chain.id}.`));
+		const chainContracts = [
+			{
+				chain_id: chain.id,
+				name: "mempool",
+				address: mempool
+			},
+			{
+				chain_id: chain.id,
+				name: "multicall",
+				address: multicall
+			},
+			{
+				chain_id: chain.id,
+				name: "v2",
+				address: v2
+			}
+		];
+		for (const contract of chainContracts) {
+			const cursorKey = `${contract.chain_id}:${contract.address.toLowerCase()}`;
+			if (seenAddresses.has(cursorKey)) return failure(new InternalServerError(`Duplicate contract address ${contract.address} for chain ${chain.id}.`));
+			seenAddresses.add(cursorKey);
+			contracts.push(contract);
+		}
+	}
+	contracts.sort((a, b) => {
+		if (a.chain_id !== b.chain_id) return a.chain_id - b.chain_id;
+		const addressCompare = a.address.toLowerCase().localeCompare(b.address.toLowerCase());
+		if (addressCompare !== 0) return addressCompare;
+		return a.name.localeCompare(b.name);
+	});
+	let cursorContract = null;
+	if (cursor) try {
+		cursorContract = parseCursor(cursor);
+	} catch (err) {
+		return failure(err);
+	}
+	const startIndex = cursorContract ? findStartIndex(contracts, cursorContract) : 0;
+	const page = contracts.slice(startIndex, startIndex + limit);
+	const nextCursor = startIndex + limit < contracts.length && page.length > 0 ? formatCursor(page.at(-1)) : null;
+	return success({
+		data: page,
+		cursor: nextCursor
+	});
+}
+function parseCursor(cursor) {
+	const [chain, address] = cursor.split(":", 2);
+	if (!chain || !address) throw new BadRequestError("Cursor must be in the format chain_id:0x...");
+	return {
+		chain_id: Number.parseInt(chain, 10),
+		address: address.toLowerCase()
+	};
+}
+function formatCursor(contract) {
+	return `${contract.chain_id}:${contract.address.toLowerCase()}`;
+}
+function findStartIndex(contracts, cursor) {
+	let low = 0;
+	let high = contracts.length;
+	while (low < high) {
+		const mid = Math.floor((low + high) / 2);
+		const current = contracts[mid];
+		if (compareContract(current, cursor) <= 0) low = mid + 1;
+		else high = mid;
+	}
+	return low;
+}
+function compareContract(contract, cursor) {
+	if (contract.chain_id !== cursor.chain_id) return contract.chain_id - cursor.chain_id;
+	return contract.address.toLowerCase().localeCompare(cursor.address.toLowerCase());
 }
 
 //#endregion
@@ -8980,28 +9702,19 @@ const __dirname = (() => {
 		return process.cwd();
 	}
 })();
-const parse_error_Description = {
-	name: "parse_error",
-	description: "Returns when an offer fails to parse due to invalid format or missing required fields"
-};
-const getGatekeeperRules = async (gatekeeper) => {
-	return [parse_error_Description, ...await gatekeeper.getRules()];
-};
 /**
 * Build the OpenAPI document for the router.
-* @param parameters - Includes a {@link RulesProvider} to fetch gatekeeper rules.
 * @returns OpenAPI document. {@link OpenAPIDocument}
 */
-async function getSwaggerJson({ gatekeeper }) {
-	return OpenApi({ rules: await getGatekeeperRules(gatekeeper) });
+async function getSwaggerJson() {
+	return OpenApi();
 }
 /**
 * Render the API documentation HTML page.
-* @param parameters - Includes a {@link RulesProvider} to fetch gatekeeper rules.
 * @returns HTML page as string.
 */
-async function getDocsHtml({ gatekeeper }) {
-	const spec = await OpenApi({ rules: await getGatekeeperRules(gatekeeper) });
+async function getDocsHtml() {
+	const spec = await OpenApi();
 	return `<!DOCTYPE html>
 <html>
   <head>
@@ -9347,13 +10060,127 @@ async function getObligations(queryParameters, db) {
 
 //#endregion
 //#region src/api/Controllers/getOffers.ts
+/**
+* Query offers with computed consumed/available/takeable values.
+* @param db - The database client. {@link Database.Core}
+* @param parameters - {@link GetOffersQueryParams}
+* @returns The offers with pagination cursor.
+*/
+async function getOffersQuery(db, parameters) {
+	const limit = parameters?.limit ?? DEFAULT_LIMIT$2;
+	const cursor = parameters?.cursor;
+	const maker = parameters?.maker;
+	if (cursor !== null && cursor !== void 0) {
+		if (!cursor.startsWith("0x") || cursor.length !== 66) throw new Error("Invalid cursor format");
+	}
+	const collateralsLateral = db.select({ collaterals: sql`COALESCE(
+        jsonb_agg(
+          jsonb_build_object(
+            'asset', ${obligationCollateralsV2.asset},
+            'oracle', ${oracles.address},
+            'lltv', ${obligationCollateralsV2.lltv}
+          )
+        ),
+        '[]'::jsonb
+      )`.as("collaterals") }).from(obligationCollateralsV2).innerJoin(oracles, sql`${obligationCollateralsV2.oracleChainId} = ${oracles.chainId}
+             AND ${obligationCollateralsV2.oracleAddress} = ${oracles.address}`).where(eq(obligationCollateralsV2.obligationId, offers.obligationId)).as("collaterals_lateral");
+	const availableLateral = db.select({ available: sql`COALESCE(SUM(
+            CASE
+              -- If asset is null, position available is 0
+              WHEN ${positions.asset} IS NULL THEN 0
+
+              -- Position asset matches loan token: no conversion needed
+              WHEN ${positions.asset} = ${obligations.loanToken} THEN
+                CASE
+                  WHEN ${callbacks.amount} IS NULL THEN COALESCE(${positions.balance}, 0)::numeric
+                  ELSE LEAST(${callbacks.amount}::numeric, COALESCE(${positions.balance}, 0)::numeric)
+                END
+
+              -- Position asset is collateral: apply oracle price * lltv
+              -- Formula: balance * price / 1e36 * lltv / 1e18
+              ELSE
+                (CASE
+                  WHEN ${callbacks.amount} IS NULL THEN COALESCE(${positions.balance}, 0)::numeric
+                  ELSE LEAST(${callbacks.amount}::numeric, COALESCE(${positions.balance}, 0)::numeric)
+                END)
+                * COALESCE(${oracles.price}, 0)::numeric / 1e36
+                * COALESCE(${obligationCollateralsV2.lltv}, 0)::numeric / 1e18
+            END
+          ), 0)`.as("available") }).from(offersCallbacks).innerJoin(callbacks, eq(offersCallbacks.callbackId, callbacks.id)).innerJoin(positions, and(eq(callbacks.positionChainId, positions.chainId), eq(callbacks.positionContract, positions.contract), eq(callbacks.positionUser, positions.user))).leftJoin(obligationCollateralsV2, and(eq(obligationCollateralsV2.obligationId, offers.obligationId), eq(obligationCollateralsV2.asset, positions.asset))).leftJoin(oracles, and(eq(oracles.chainId, obligationCollateralsV2.oracleChainId), eq(oracles.address, obligationCollateralsV2.oracleAddress))).where(eq(offersCallbacks.offerHash, offers.hash)).as("available_lateral");
+	const rows = (await db.select({
+		hash: offers.hash,
+		maker: offers.groupMaker,
+		assets: offers.assets,
+		obligationUnits: offers.obligationUnits,
+		obligationShares: offers.obligationShares,
+		consumed: groups.consumed,
+		price: offers.price,
+		maturity: offers.maturity,
+		expiry: offers.expiry,
+		start: offers.start,
+		group: offers.group,
+		session: offers.session,
+		buy: offers.buy,
+		chainId: obligations.chainId,
+		loanToken: obligations.loanToken,
+		callbackAddress: offers.callbackAddress,
+		callbackData: offers.callbackData,
+		collaterals: collateralsLateral.collaterals,
+		blockNumber: offers.blockNumber,
+		available: sql`COALESCE(${availableLateral.available}::numeric, 0)`.as("available"),
+		takeable: sql`FLOOR(GREATEST(
+            0,
+            LEAST(
+              ${offers.assets}::numeric - ${groups.consumed}::numeric,
+              COALESCE(${availableLateral.available}::numeric, 0)
+            )
+          ))`.as("takeable")
+	}).from(offers).innerJoin(obligations, eq(offers.obligationId, obligations.obligationId)).innerJoin(groups, and(eq(offers.groupChainId, groups.chainId), eq(offers.groupMaker, groups.maker), eq(offers.group, groups.group))).innerJoinLateral(collateralsLateral, sql`true`).leftJoinLateral(availableLateral, sql`true`).where(and(cursor !== null && cursor !== void 0 ? gt(offers.hash, cursor) : void 0, maker !== void 0 ? eq(offers.groupMaker, maker.toLowerCase()) : void 0, maker === void 0 ? sql`GREATEST(0, LEAST(
+                  ${offers.assets}::numeric - ${groups.consumed}::numeric,
+                  COALESCE(${availableLateral.available}::numeric, 0)
+                )) > 0` : void 0)).orderBy(asc(offers.hash)).limit(limit)).map((row) => {
+		return {
+			hash: row.hash,
+			maker: row.maker,
+			assets: BigInt(row.assets),
+			obligationUnits: BigInt(row.obligationUnits),
+			obligationShares: BigInt(row.obligationShares),
+			price: BigInt(row.price),
+			maturity: from$16(row.maturity),
+			expiry: row.expiry,
+			start: row.start,
+			group: row.group,
+			session: row.session,
+			buy: row.buy,
+			chainId: row.chainId,
+			loanToken: row.loanToken,
+			collaterals: row.collaterals.map((c) => ({
+				asset: c.asset,
+				oracle: c.oracle,
+				lltv: BigInt(c.lltv)
+			})).sort((a, b) => a.asset.toLowerCase().localeCompare(b.asset.toLowerCase())),
+			callback: {
+				address: row.callbackAddress,
+				data: row.callbackData
+			},
+			consumed: BigInt(row.consumed),
+			available: BigInt(String(row.available ?? "0").split(".")[0] ?? "0"),
+			takeable: BigInt(String(row.takeable ?? "0").split(".")[0] ?? "0"),
+			blockNumber: row.blockNumber
+		};
+	});
+	return {
+		rows,
+		nextCursor: rows.length === limit ? rows[rows.length - 1].hash : null
+	};
+}
 async function getOffers(queryParameters, db) {
 	const logger = getLogger();
 	const result = safeParse("get_offers", queryParameters, (issue) => issue.message);
 	if (!result.success) return failure(result.error);
 	const query = result.data;
 	try {
-		const { rows, nextCursor } = query.maker ? await db.offers.get({
+		const { rows, nextCursor } = query.maker ? await getOffersQuery(db, {
 			maker: query.maker,
 			cursor: query.cursor,
 			limit: query.limit
@@ -9421,6 +10248,35 @@ async function getUserPositions(queryParameters, db) {
 	}
 }
 
+//#endregion
+//#region src/api/Controllers/resolveCallbackTypes.ts
+/**
+* Resolve callback types for a list of callback addresses grouped by chain.
+* @param body - Request body with callback addresses. {@link CallbackTypesRequest}
+* @param chains - Chains to resolve callback types against. {@link Chain.Chain}
+* @returns Callback types grouped by chain. {@link CallbackTypesPayload}
+*/
+async function resolveCallbackTypes$1(body, chains) {
+	const result = safeParse("callback_types", body, (issue) => issue.message);
+	if (!result.success) return failure(result.error);
+	const request = result.data;
+	const chainIds = new Set(chains.map((chain) => chain.id));
+	const unknown = request.callbacks.find((entry) => !chainIds.has(entry.chain_id));
+	if (unknown) return failure(new BadRequestError(`Unknown chain id ${unknown.chain_id}`));
+	try {
+		const data = resolveCallbackTypes$2({
+			chains,
+			request
+		});
+		return success({
+			data,
+			cursor: null
+		});
+	} catch (err) {
+		return failure(err);
+	}
+}
+
 //#endregion
 //#region src/api/Api.ts
 function from(config) {
@@ -9494,6 +10350,21 @@ function serve$1(parameters) {
 			return c.json(failure$1.body, failure$1.statusCode);
 		}
 	});
+	app.post("/v1/callbacks", async (c) => {
+		let body;
+		try {
+			body = await c.req.json();
+		} catch (err) {
+			const failure$3 = failure(err);
+			return c.json(failure$3.body, failure$3.statusCode);
+		}
+		if (body === null || typeof body !== "object") {
+			const failure$2 = failure(new BadRequestError("Request body must be a JSON object"));
+			return c.json(failure$2.body, failure$2.statusCode);
+		}
+		const { statusCode, body: responseBody } = await resolveCallbackTypes$1(body, chainRegistry.list());
+		return c.json(responseBody, statusCode);
+	});
 	app.get("/v1/users/:userAddress/positions", async (c) => {
 		const query = c.req.query();
 		const { statusCode, body } = await getUserPositions({
@@ -9515,12 +10386,21 @@ function serve$1(parameters) {
 		const { statusCode, body } = await getHealthChains(c.req.query(), db, void 0, chainRegistry);
 		return c.json(body, statusCode);
 	});
-	app.get("/v1/config", async (c) => {
-		const { statusCode, body } = await getConfig(chainRegistry);
+	app.get("/v1/config/contracts", async (c) => {
+		const { statusCode, body } = await getConfigContracts(c.req.query(), chainRegistry);
 		return c.json(body, statusCode);
 	});
-	app.get("/docs/openapi", async (c) => c.text(JSON.stringify(await getSwaggerJson({ gatekeeper })), 200, { "Content-Type": "application/json; charset=utf-8" }));
-	app.get("/docs/api", async (c) => c.html(await getDocsHtml({ gatekeeper }), 200));
+	app.get("/v1/config/rules", async (c) => {
+		try {
+			const { statusCode, body } = await gatekeeper.getConfigRules(c.req.query());
+			return c.json(body, statusCode);
+		} catch (err) {
+			const failure$4 = failure(err);
+			return c.json(failure$4.body, failure$4.statusCode);
+		}
+	});
+	app.get("/docs/openapi", async (c) => c.text(JSON.stringify(await getSwaggerJson()), 200, { "Content-Type": "application/json; charset=utf-8" }));
+	app.get("/docs/api", async (c) => c.html(await getDocsHtml(), 200));
 	app.get("/docs", async (c) => c.html(await getIntegratorDocsHtml(), 200));
 	serve({
 		fetch: app.fetch,
@@ -9528,6 +10408,120 @@ function serve$1(parameters) {
 	});
 }
 
+//#endregion
+//#region src/gatekeeper/Client.ts
+const DEFAULT_TIMEOUT_MS = 1e4;
+/**
+* Create an HTTP client for a gatekeeper service.
+* @param config - Gatekeeper client configuration. {@link ClientConfig}
+* @returns An HTTP-backed gatekeeper client. {@link GatekeeperClient}
+*/
+function createHttpClient(config) {
+	const fetchFn = config.fetchFn ?? fetch;
+	const timeoutMs = config.timeoutMs ?? DEFAULT_TIMEOUT_MS;
+	const baseUrl = normalizeBaseUrl(config.baseUrl);
+	const baseHeaders = config.originSecret ? { "x-origin-verify": config.originSecret } : void 0;
+	const request = async (path, init) => {
+		const controller = new AbortController();
+		const timeout = setTimeout(() => controller.abort(), timeoutMs);
+		try {
+			return await fetchFn(`${baseUrl}${path}`, {
+				...init,
+				headers: mergeHeaders(baseHeaders, init.headers),
+				signal: controller.signal
+			});
+		} finally {
+			clearTimeout(timeout);
+		}
+	};
+	const validate = async (body) => {
+		const response = await request("/v1/validate", {
+			method: "POST",
+			headers: { "content-type": "application/json" },
+			body: JSON.stringify(body)
+		});
+		const json = await response.json();
+		return {
+			statusCode: response.status,
+			body: json
+		};
+	};
+	const getConfigRules = async (query) => {
+		const params = new URLSearchParams();
+		if (query?.cursor) params.set("cursor", query.cursor);
+		if (query?.limit !== void 0) params.set("limit", query.limit.toString());
+		if (query?.types !== void 0) {
+			const typesValue = Array.isArray(query.types) ? query.types.join(",") : query.types;
+			if (typesValue.length > 0) params.set("types", typesValue);
+		}
+		const response = await request(params.size > 0 ? `/v1/config/rules?${params.toString()}` : "/v1/config/rules", { method: "GET" });
+		const json = await response.json();
+		return {
+			statusCode: response.status,
+			body: json
+		};
+	};
+	const isAllowed = async (offers) => {
+		const { statusCode, body } = await validate({ offers: offers.map((offer) => toSnakeCase(offer)) });
+		if (statusCode !== 200) {
+			const errorMessage = extractErrorMessage(body);
+			throw new Error(`Gatekeeper validation failed: ${errorMessage ?? `status ${statusCode}`}`);
+		}
+		const data = body.data;
+		if (!data || typeof data !== "object") throw new Error("Gatekeeper validation response is invalid.");
+		if ("issues" in data) {
+			const issues = data.issues.map((issue) => ({
+				ruleName: issue.rule,
+				message: issue.message,
+				item: offers[issue.index]
+			}));
+			const invalidIndices = new Set(data.issues.map((issue) => issue.index));
+			return {
+				valid: offers.filter((_, index) => !invalidIndices.has(index)),
+				issues
+			};
+		}
+		if (!("payload" in data) || !("root" in data)) throw new Error("Gatekeeper validation response is missing payload data.");
+		return {
+			valid: offers.slice(),
+			issues: []
+		};
+	};
+	const getCallbackTypes = async (requestPayload) => {
+		const response = await request("/v1/callbacks", {
+			method: "POST",
+			headers: { "content-type": "application/json" },
+			body: JSON.stringify(requestPayload)
+		});
+		const json = await response.json();
+		if (!response.ok) throw new Error(`Gatekeeper callbacks request failed: ${extractErrorMessage(json) ?? response.statusText}`);
+		if (!("data" in json) || !Array.isArray(json.data)) throw new Error("Gatekeeper callbacks response is invalid.");
+		return json.data;
+	};
+	return {
+		baseUrl,
+		validate,
+		getConfigRules,
+		isAllowed,
+		getCallbackTypes
+	};
+}
+function mergeHeaders(base, extra) {
+	if (!base && !extra) return void 0;
+	const merged = new Headers(base ?? void 0);
+	if (extra) for (const [key, value] of new Headers(extra).entries()) merged.set(key, value);
+	return merged;
+}
+function normalizeBaseUrl(url) {
+	return url.trim().replace(/\/+$/, "");
+}
+function extractErrorMessage(payload) {
+	if (!payload || typeof payload !== "object") return void 0;
+	const error = payload.error;
+	if (!error || typeof error !== "object") return void 0;
+	return typeof error.message === "string" ? error.message : void 0;
+}
+
 //#endregion
 //#region src/cli/commands/start.ts
 const startCmd = new RouterCmd("start");
@@ -9538,9 +10532,10 @@ startCmd.description("Start Router services.").addOption(new Option("--mock <n>"
 		let gatekeeperUrl = gatekeeperConfig?.url;
 		let gatekeeperHandle = null;
 		if (!gatekeeperUrl) {
-			const gatekeeperCore = create$17({ rules: morphoRules(chainRegistry.list()) });
+			const gatekeeperCore = create$20({ rules: morphoRules(chainRegistry.list()) });
 			gatekeeperHandle = await start$1({
 				gatekeeper: gatekeeperCore,
+				chainRegistry,
 				port: gatekeeperConfig?.port ?? 8082
 			});
 			gatekeeperUrl = gatekeeperHandle.url;
@@ -9552,72 +10547,36 @@ startCmd.description("Start Router services.").addOption(new Option("--mock <n>"
 		}
 		const gatekeeper = createHttpClient({
 			baseUrl: gatekeeperUrl ?? "http://localhost:8082",
-			timeoutMs: gatekeeperConfig?.timeoutMs
+			timeoutMs: gatekeeperConfig?.timeoutMs,
+			originSecret: gatekeeperConfig?.originSecret
 		});
 		if (mock !== void 0 && mock > 0) {
-			const configuredChains = chainRegistry.list();
-			const tokens = {
-				"0xA0b86991c6218b36c1d19D4a2e9Eb0cE3606eB48": 6,
-				"0x6B175474E89094C44Da98b954EedeAC495271d0F": 18,
-				"0xC02aaA39b223FE8D0A0e5C4F27eAD9083C756Cc2": 18,
-				"0x2260FAC5E5542a773Aa44fBCfeDf7C193bc2C599": 8,
-				"0x4200000000000000000000000000000000000006": 18,
-				"0x833589fCD6eDb6E08f4c7C32D4f71b54bdA02913": 6,
-				"0x50c5725949A6F0c72E6C4a641F24049A917DB0Cb": 18
-			};
-			const now = Math.floor(Date.now() / 1e3);
-			const offerBlockNumber = 1;
-			const positionBlockNumber = offerBlockNumber + 1;
-			const start = Math.max(0, now - 60);
-			const expiry = now + 3600;
-			const maturity = from$16("end_of_next_month");
-			const oraclePrice = 10n ** 36n;
-			const offers = createMockOffers({
-				count: mock,
-				chains: configuredChains,
-				loanTokens: Object.keys(tokens).map((key) => key),
-				assetsDecimals: tokens,
-				start,
-				expiry,
-				maturity,
-				chainRegistry
+			const offers = await seedMockOffers({
+				db,
+				gatekeeper,
+				chainRegistry,
+				count: mock
 			});
-			await db.offers.create([{
-				blockNumber: offerBlockNumber,
-				offers
-			}]);
-			await db.oracles.upsert(seedMockOracles(offers, oraclePrice, positionBlockNumber));
-			for (const offer of offers) {
-				if (offer.callback.data === "0x") continue;
-				const chain = chainRegistry.getById(offer.chainId);
-				if (!chain) continue;
-				const callbackType = getCallbackType(chain.name, offer.callback.address);
-				if (!callbackType) continue;
-				const callbacks = decode$1(callbackType, offer.callback.data);
-				for (const cb of callbacks) {
-					const positionAsset = callbackType === Type$1.SellERC20Callback ? cb.contract : offer.loanToken;
-					await db.positions.upsert([from$9({
-						chainId: offer.chainId,
-						contract: cb.contract,
-						user: offer.maker,
-						type: callbackType === Type$1.BuyVaultV1Callback ? Type.VAULT_V1 : Type.ERC20,
-						balance: cb.amount * 2n,
-						asset: positionAsset,
-						blockNumber: positionBlockNumber
-					})]);
-				}
-			}
 			logger.info({
 				msg: `Offers seeded`,
-				count: mock
+				count: offers.length
 			});
 		}
 		if (file) {
 			const offers = await getOffersFromFile(file);
-			await db.offers.create([{
-				blockNumber: 1,
-				offers
-			}]);
+			const offerBlockNumber = 1;
+			const positionBlockNumber = offerBlockNumber + 1;
+			await seedOffers({
+				db,
+				offers,
+				blockNumber: offerBlockNumber
+			});
+			await seedOfferAssociations({
+				db,
+				gatekeeper,
+				offers,
+				blockNumber: positionBlockNumber
+			});
 			logger.info({
 				msg: `Offers seeded from file`,
 				count: offers.length,
@@ -9669,10 +10628,59 @@ startCmd.description("Start Router services.").addOption(new Option("--mock <n>"
 		process.stdin.resume();
 	});
 });
+/**
+* Seed mock offers and their dependencies for the router API.
+* @param parameters - Seed parameters. {@link seedMockOffers.Parameters}
+* @returns The generated mock offers. {@link seedMockOffers.ReturnType}
+*/
+async function seedMockOffers(parameters) {
+	const { db, gatekeeper, chainRegistry, count } = parameters;
+	if (count <= 0) return [];
+	const configuredChains = chainRegistry.list();
+	const tokens = {
+		"0xA0b86991c6218b36c1d19D4a2e9Eb0cE3606eB48": 6,
+		"0x6B175474E89094C44Da98b954EedeAC495271d0F": 18,
+		"0xC02aaA39b223FE8D0A0e5C4F27eAD9083C756Cc2": 18,
+		"0x2260FAC5E5542a773Aa44fBCfeDf7C193bc2C599": 8,
+		"0x4200000000000000000000000000000000000006": 18,
+		"0x833589fCD6eDb6E08f4c7C32D4f71b54bdA02913": 6,
+		"0x50c5725949A6F0c72E6C4a641F24049A917DB0Cb": 18
+	};
+	const now = Math.floor(Date.now() / 1e3);
+	const offerBlockNumber = 1;
+	const positionBlockNumber = offerBlockNumber + 1;
+	const start = Math.max(0, now - 60);
+	const expiry = now + 3600;
+	const maturity = from$16("end_of_next_month");
+	const oraclePrice = 10n ** 36n;
+	const offers = createMockOffers({
+		count,
+		chains: configuredChains,
+		loanTokens: Object.keys(tokens).map((key) => key),
+		assetsDecimals: tokens,
+		start,
+		expiry,
+		maturity,
+		chainRegistry
+	});
+	await seedOffers({
+		db,
+		offers,
+		blockNumber: offerBlockNumber
+	});
+	await db.oracles.upsert(seedMockOracles(offers, oraclePrice, positionBlockNumber));
+	await seedOfferAssociations({
+		db,
+		gatekeeper,
+		offers,
+		blockNumber: positionBlockNumber
+	});
+	return offers;
+}
 async function getOffersFromFile(filePath) {
 	const content = await readFile(filePath, "utf-8");
 	const data = JSON.parse(content);
-	return Array.isArray(data) ? data.map(from$11) : [from$11(data)];
+	return Array.isArray(data) ? data.map(from$12) : [from$12(data)];
 }
 function createMockOffers(parameters) {
 	const { count, chains, loanTokens, assetsDecimals, start, expiry, maturity, chainRegistry } = parameters;
@@ -9687,13 +10695,11 @@ function createMockOffers(parameters) {
 			maturity,
 			buy
 		});
-		const chain = chainRegistry.getById(offer.chainId);
-		if (!chain) throw new Error(`Missing chain config for id ${offer.chainId}`);
+		if (!chainRegistry.getById(offer.chainId)) throw new Error(`Missing chain config for id ${offer.chainId}`);
 		const callbackType = buy ? Type$1.BuyVaultV1Callback : Type$1.SellERC20Callback;
-		const callbackAddress = getCallbackTypeAddresses(chain.name, callbackType)[0];
-		if (!callbackAddress) throw new Error(`Missing callback addresses for ${chain.name} (${buy ? "buy" : "sell"} offers)`);
+		const callbackAddress = buy ? BUY_CALLBACK_ADDRESS : SELL_CALLBACK_ADDRESS;
 		const callbackData = buildMockCallbackData(callbackType, offer);
-		return from$11({
+		return from$12({
 			...offer,
 			callback: {
 				address: callbackAddress,
@@ -9719,7 +10725,7 @@ function seedMockOracles(offers, price, blockNumber) {
 	for (const offer of offers) for (const collateral of offer.collaterals) {
 		const key = `${offer.chainId}-${collateral.oracle}`.toLowerCase();
 		if (oracleMap.has(key)) continue;
-		oracleMap.set(key, from$10({
+		oracleMap.set(key, from$11({
 			chainId: offer.chainId,
 			address: collateral.oracle,
 			price: price.toString(),
@@ -9728,6 +10734,158 @@ function seedMockOracles(offers, price, blockNumber) {
 	}
 	return Array.from(oracleMap.values());
 }
+const BUY_CALLBACK_ADDRESS = "0x3333333333333333333333333333333333333333";
+const SELL_CALLBACK_ADDRESS = "0x1111111111111111111111111111111111111111";
+async function seedOffers(parameters) {
+	const { db, offers, blockNumber } = parameters;
+	if (offers.length === 0) return;
+	const dependencies = buildOfferDependencies({
+		offers,
+		blockNumber
+	});
+	await db.oracles.upsert(dependencies.oracles);
+	await db.obligations.create(dependencies.obligations);
+	await db.groups.create(dependencies.groups);
+	await db.offers.create([{
+		blockNumber,
+		offers
+	}]);
+}
+async function seedOfferAssociations(parameters) {
+	const { db, gatekeeper, offers, blockNumber } = parameters;
+	if (offers.length === 0) return;
+	const { callbacks, positions, lots } = buildOfferAssociationsFromOffers({
+		offers,
+		callbackTypes: await resolveCallbackTypes({
+			gatekeeper,
+			offers
+		}),
+		blockNumber
+	});
+	if (positions.length > 0) await db.positions.upsert(positions);
+	if (callbacks.length > 0) await db.callbacks.upsert(callbacks);
+	if (lots.length > 0) await db.lots.create(lots);
+}
+function buildOfferDependencies(parameters) {
+	const { offers, blockNumber } = parameters;
+	const obligationsById = /* @__PURE__ */ new Map();
+	const oraclesByKey = /* @__PURE__ */ new Map();
+	const groupsByKey = /* @__PURE__ */ new Map();
+	for (const offer of offers) {
+		const obligationId$1 = obligationId(offer);
+		if (!obligationsById.get(obligationId$1)) obligationsById.set(obligationId$1, from$13({
+			chainId: offer.chainId,
+			loanToken: offer.loanToken,
+			maturity: offer.maturity,
+			collaterals: offer.collaterals
+		}));
+		for (const collateral of offer.collaterals) {
+			const oracleKey = `${offer.chainId}-${collateral.oracle}`.toLowerCase();
+			if (!oraclesByKey.has(oracleKey)) oraclesByKey.set(oracleKey, from$11({
+				chainId: offer.chainId,
+				address: collateral.oracle,
+				price: null,
+				blockNumber
+			}));
+		}
+		const groupKey = `${offer.chainId}-${offer.maker}-${offer.group}`.toLowerCase();
+		if (!groupsByKey.has(groupKey)) groupsByKey.set(groupKey, {
+			chainId: offer.chainId,
+			maker: offer.maker,
+			group: offer.group,
+			blockNumber
+		});
+	}
+	return {
+		obligations: Array.from(obligationsById.values()),
+		oracles: Array.from(oraclesByKey.values()),
+		groups: Array.from(groupsByKey.values())
+	};
+}
+async function resolveCallbackTypes(parameters) {
+	const { gatekeeper, offers } = parameters;
+	const addressesByChain = /* @__PURE__ */ new Map();
+	for (const offer of offers) {
+		if (offer.callback.data === "0x") continue;
+		const set = addressesByChain.get(offer.chainId) ?? /* @__PURE__ */ new Set();
+		set.add(offer.callback.address.toLowerCase());
+		addressesByChain.set(offer.chainId, set);
+	}
+	if (addressesByChain.size === 0) return /* @__PURE__ */ new Map();
+	const request = { callbacks: Array.from(addressesByChain.entries()).map(([chainId, addresses]) => ({
+		chain_id: chainId,
+		addresses: Array.from(addresses)
+	})) };
+	const response = await gatekeeper.getCallbackTypes(request);
+	const typeByAddress = /* @__PURE__ */ new Map();
+	for (const entry of response) {
+		const chainId = entry.chain_id;
+		for (const [key, list] of Object.entries(entry)) {
+			if (key === "chain_id" || key === "not_supported") continue;
+			if (!Array.isArray(list)) continue;
+			for (const address of list) {
+				const mapKey = `${chainId}-${address.toLowerCase()}`;
+				typeByAddress.set(mapKey, key);
+			}
+		}
+	}
+	return typeByAddress;
+}
+function buildOfferAssociationsFromOffers(parameters) {
+	const { offers, callbackTypes, blockNumber } = parameters;
+	const callbacks = [];
+	const positions = [];
+	const lots = [];
+	for (const offer of offers) {
+		if (offer.callback.data === "0x") continue;
+		const key = `${offer.chainId}-${offer.callback.address.toLowerCase()}`;
+		const callbackType = callbackTypes.get(key);
+		if (!callbackType) continue;
+		let decoded;
+		try {
+			decoded = decode$1(callbackType, offer.callback.data);
+		} catch (err) {
+			const error = err instanceof Error ? err : new Error(String(err));
+			throw new Error("Failed to decode callback data", { cause: error });
+		}
+		if (decoded.length === 0) continue;
+		callbacks.push({
+			offerHash: hash(offer),
+			callbacks: decoded.map((callback) => ({
+				chainId: offer.chainId,
+				contract: callback.contract,
+				user: offer.maker,
+				amount: callback.amount
+			}))
+		});
+		for (const callback of decoded) {
+			const positionType = callbackType === Type$1.BuyVaultV1Callback ? Type.VAULT_V1 : Type.ERC20;
+			const positionAsset = callbackType === Type$1.BuyVaultV1Callback ? offer.loanToken : callback.contract;
+			positions.push(from$10({
+				chainId: offer.chainId,
+				contract: callback.contract,
+				user: offer.maker,
+				type: positionType,
+				balance: callback.amount * 2n,
+				asset: positionAsset,
+				blockNumber
+			}));
+			const isLoanPosition = positionAsset.toLowerCase() === offer.loanToken.toLowerCase();
+			lots.push({
+				positionChainId: offer.chainId,
+				positionContract: callback.contract,
+				positionUser: offer.maker,
+				group: offer.group,
+				size: isLoanPosition ? offer.assets : callback.amount
+			});
+		}
+	}
+	return {
+		callbacks,
+		positions,
+		lots
+	};
+}
 
 //#endregion
 //#region src/cli/cli.ts