@morpho-dev/router 0.5.0 → 0.6.0

package/dist/index.browser.js

@@ -1413,6 +1413,7 @@ var Obligation_exports = /* @__PURE__ */ __exportAll({
 	InvalidObligationError: () => InvalidObligationError,
 	ObligationSchema: () => ObligationSchema,
 	from: () => from$10,
+	fromOffer: () => fromOffer$1,
 	fromSnakeCase: () => fromSnakeCase$2,
 	id: () => id,
 	random: () => random$2
@@ -1541,6 +1542,21 @@ function random$2() {
 		maturity: from$11("end_of_next_quarter")
 	});
 }
+/**
+* Creates an obligation from an offer.
+* @constructor
+*
+* @param offer - The offer to create the obligation from.
+* @returns The created obligation. {@link fromOffer.ReturnType}
+*/
+function fromOffer$1(offer) {
+	return from$10({
+		chainId: offer.chainId,
+		loanToken: offer.loanToken,
+		collaterals: offer.collaterals,
+		maturity: offer.maturity
+	});
+}
 var InvalidObligationError = class extends BaseError {
 	constructor(error) {
 		super("Invalid obligation.", { cause: error });
@@ -1554,273 +1570,22 @@ var CollateralsAreNotSortedError = class extends BaseError {
 	}
 };
 
-//#endregion
-//#region src/core/Tree.ts
-var Tree_exports = /* @__PURE__ */ __exportAll({
-	DecodeError: () => DecodeError,
-	EncodeError: () => EncodeError,
-	TreeError: () => TreeError,
-	VERSION: () => VERSION,
-	decode: () => decode$1,
-	encode: () => encode$1,
-	encodeUnsigned: () => encodeUnsigned,
-	from: () => from$9,
-	proofs: () => proofs
-});
-const VERSION = 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$9 = (offers) => {
-	const leaves = offers.map((offer) => [hash(offer)]);
-	const tree = _openzeppelin_merkle_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" || !(0, viem.isHex)(value)) throw new DecodeError(`${name} is not a valid hex string`);
-	if ((0, viem.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 = (0, viem.hashMessage)({ raw: root });
-	try {
-		return await (0, viem.recoverAddress)({
-			hash,
-			signature
-		});
-	} catch {
-		throw new DecodeError("signature recovery failed");
-	}
-};
-/**
-* Encodes a merkle tree with signature into hex calldata for onchain broadcast.
-*
-* Layout: `0x{vv}{gzip([...offers])}{root}{signature}` where:
-* - `{vv}`: 1-byte version (currently 0x01)
-* - `{gzip([...offers])}`: gzipped JSON array of serialized offers
-* - `{root}`: 32-byte merkle root
-* - `{signature}`: 65-byte EIP-191 signature over raw root bytes
-*
-* Validates signature authenticity and root integrity before encoding.
-*
-* @example
-* ```typescript
-* const tree = Tree.from(offers);
-* const signature = await wallet.signMessage({ message: { raw: tree.root } });
-* const calldata = await Tree.encode(tree, signature);
-* await broadcast(calldata);
-* ```
-*
-* @example
-* Manual construction (for advanced users):
-* ```typescript
-* const tree = Tree.from(offers);
-* const compressed = gzip(JSON.stringify(tree.offers.map(Offer.serialize)));
-* const partial = `0x01${bytesToHex(compressed)}${tree.root.slice(2)}`;
-* const signature = await wallet.signMessage({ message: { raw: tree.root } });
-* const calldata = `${partial}${signature.slice(2)}`;
-* ```
-*
-* @param tree - Merkle tree of offers
-* @param signature - EIP-191 signature over raw root bytes
-* @returns Hex-encoded calldata ready for onchain broadcast
-* @throws {EncodeError} If signature verification fails or root mismatch
-*/
-const encode$1 = async (tree, signature) => {
-	validateTreeForEncoding(tree);
-	await verifySignatureAndRecoverAddress({
-		root: tree.root,
-		signature
-	});
-	const unsigned = encodeUnsignedBytes(tree);
-	const sigBytes = (0, viem.hexToBytes)(signature);
-	const encoded = new Uint8Array(unsigned.length + sigBytes.length);
-	encoded.set(unsigned, 0);
-	encoded.set(sigBytes, unsigned.length);
-	return (0, viem.bytesToHex)(encoded);
-};
-/**
-* 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 (0, viem.bytesToHex)(encodeUnsignedBytes(tree));
-};
-const validateTreeForEncoding = (tree) => {
-	if (VERSION > 255) throw new EncodeError(`version overflow: ${VERSION} exceeds 255`);
-	const computed = from$9(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 = (0, pako.gzip)(JSON.stringify(offersPayload));
-	const rootBytes = (0, viem.hexToBytes)(tree.root);
-	const encoded = new Uint8Array(1 + compressed.length + 32);
-	encoded[0] = VERSION;
-	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$1 = async (encoded) => {
-	const bytes = (0, viem.hexToBytes)(encoded);
-	if (bytes.length < 98) throw new DecodeError("payload too short");
-	const version = bytes[0];
-	if (version !== (VERSION & 255)) throw new DecodeError(`invalid version: expected ${VERSION}, got ${version ?? 0}`);
-	const signature = (0, viem.bytesToHex)(bytes.slice(-65));
-	const root = (0, viem.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 = (0, pako.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$9(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 {
-	constructor(reason) {
-		super(`Tree error: ${reason}`);
-		_defineProperty(this, "name", "Tree.TreeError");
-	}
-};
-/**
-* Error thrown during tree encoding.
-* Indicates validation failures (signature, root mismatch, mixed makers).
-*/
-var EncodeError = class extends BaseError {
-	constructor(reason) {
-		super(`Failed to encode tree: ${reason}`);
-		_defineProperty(this, "name", "Tree.EncodeError");
-	}
-};
-/**
-* Error thrown during tree decoding.
-* Indicates payload corruption, version mismatch, or validation failures.
-*/
-var DecodeError = class extends BaseError {
-	constructor(reason) {
-		super(`Failed to decode tree: ${reason}`);
-		_defineProperty(this, "name", "Tree.DecodeError");
-	}
-};
-
 //#endregion
 //#region src/core/Offer.ts
 var Offer_exports = /* @__PURE__ */ __exportAll({
-	AccountNotSetError: () => AccountNotSetError,
 	InvalidOfferError: () => InvalidOfferError,
 	OfferSchema: () => OfferSchema,
 	Status: () => Status,
 	consumedEvent: () => consumedEvent,
-	decode: () => decode,
+	decode: () => decode$1,
 	domain: () => domain,
-	encode: () => encode,
-	from: () => from$8,
+	encode: () => encode$1,
+	from: () => from$9,
 	fromSnakeCase: () => fromSnakeCase$1,
 	hash: () => hash,
 	obligationId: () => obligationId,
 	random: () => random$1,
 	serialize: () => serialize,
-	sign: () => sign,
-	signatureMsg: () => signatureMsg,
 	toSnakeCase: () => toSnakeCase,
 	types: () => types
 });
@@ -1873,7 +1638,7 @@ const OfferSchema = () => {
 * @param input - The offer to create.
 * @returns The created offer.
 */
-function from$8(input) {
+function from$9(input) {
 	try {
 		return OfferSchema().parse(input);
 	} catch (error) {
@@ -1887,7 +1652,7 @@ function from$8(input) {
 * @returns The created offer.
 */
 function fromSnakeCase$1(input) {
-	return from$8(fromSnakeCase$3(input));
+	return from$9(fromSnakeCase$3(input));
 }
 /**
 * Converts an offer to a snake case object.
@@ -1981,7 +1746,7 @@ function random$1(config) {
 			})
 		};
 	})();
-	return from$8({
+	return from$9({
 		maker: config?.maker ?? address(),
 		assets: assetsScaled,
 		obligationUnits: config?.obligationUnits ?? 0n,
@@ -2109,23 +1874,6 @@ const types = {
 		type: "bytes"
 	}]
 };
-/**
-* Signs an array of offers.
-* @throws {Error} If the wallet account is not set.
-* @param offers - The offers to sign.
-* @param wallet - The wallet to sign the offers with.
-* @returns The signed offers.
-*/
-async function sign(offers, wallet) {
-	if (!wallet.account) throw new AccountNotSetError();
-	return wallet.signMessage({
-		account: wallet.account,
-		message: { raw: signatureMsg(offers) }
-	});
-}
-function signatureMsg(offers) {
-	return from$9(offers).root;
-}
 function hash(offer) {
 	const cached = offer[HASH_CACHE];
 	if (cached) return cached;
@@ -2252,7 +2000,7 @@ const OfferAbi = [
 		}]
 	}
 ];
-function encode(offer) {
+function encode$1(offer) {
 	return (0, viem.encodeAbiParameters)(OfferAbi, [
 		offer.maker,
 		offer.assets,
@@ -2271,14 +2019,14 @@ function encode(offer) {
 		offer.callback
 	]);
 }
-function decode(data) {
+function decode$1(data) {
 	let decoded;
 	try {
 		decoded = (0, viem.decodeAbiParameters)(OfferAbi, data);
 	} catch (error) {
 		throw new InvalidOfferError(error);
 	}
-	return from$8({
+	return from$9({
 		maker: decoded[0],
 		assets: decoded[1],
 		obligationUnits: decoded[2],
@@ -2357,25 +2105,22 @@ var InvalidOfferError = class InvalidOfferError extends BaseError {
 		return `Invalid offer. ${InvalidOfferError.formatDetails(this.cause)}`;
 	}
 };
-var AccountNotSetError = class extends BaseError {
-	constructor() {
-		super("Account not set.");
-		_defineProperty(this, "name", "Offer.AccountNotSetError");
-	}
-};
 
 //#endregion
 //#region src/core/Oracle.ts
 var Oracle_exports = /* @__PURE__ */ __exportAll({
 	Conversion: () => Conversion,
-	from: () => from$7
+	from: () => from$8,
+	fromCollateral: () => fromCollateral,
+	fromOffer: () => fromOffer,
+	fromOffers: () => fromOffers
 });
 /**
 * Create an Oracle from a plain object.
 * @param data - The data to create the oracle from.
 * @returns The created oracle.
 */
-function from$7(data) {
+function from$8(data) {
 	return {
 		chainId: data.chainId,
 		address: data.address.toLowerCase(),
@@ -2383,8 +2128,61 @@ function from$7(data) {
 		blockNumber: data.blockNumber
 	};
 }
-let Conversion;
-(function(_Conversion) {
+/**
+* Creates an oracle from a collateral.
+* @constructor
+*
+* @param parameters - {@link fromCollateral.Parameters}
+* @returns The created oracle. {@link fromCollateral.ReturnType}
+*/
+function fromCollateral(parameters) {
+	const { chainId, collateral, blockNumber, price = null } = parameters;
+	return {
+		chainId,
+		address: collateral.oracle.toLowerCase(),
+		price,
+		blockNumber
+	};
+}
+/**
+* Creates oracles from a single offer.
+* @constructor
+*
+* @param parameters - {@link fromOffer.Parameters}
+* @returns The created oracles. {@link fromOffer.ReturnType}
+*/
+function fromOffer(parameters) {
+	const { offer, blockNumber, price = null } = parameters;
+	return fromOffers({
+		offers: [offer],
+		blockNumber,
+		price
+	});
+}
+/**
+* Creates oracles from a list of offers.
+* @constructor
+*
+* @param parameters - {@link fromOffers.Parameters}
+* @returns The created oracles. {@link fromOffers.ReturnType}
+*/
+function fromOffers(parameters) {
+	const { offers, blockNumber, price = null } = parameters;
+	const rowsByKey = /* @__PURE__ */ new Map();
+	for (const offer of offers) for (const collateral of offer.collaterals) {
+		const key = `${offer.chainId}-${collateral.oracle}`.toLowerCase();
+		if (rowsByKey.has(key)) continue;
+		rowsByKey.set(key, fromCollateral({
+			chainId: offer.chainId,
+			collateral,
+			blockNumber,
+			price
+		}));
+	}
+	return Array.from(rowsByKey.values());
+}
+let Conversion;
+(function(_Conversion) {
 	function collateralToLoan(amount, params) {
 		return amount * params.price / 10n ** 36n * params.lltv / 10n ** 18n;
 	}
@@ -2400,7 +2198,7 @@ let Conversion;
 //#region src/core/Position.ts
 var Position_exports = /* @__PURE__ */ __exportAll({
 	Type: () => Type,
-	from: () => from$6
+	from: () => from$7
 });
 let Type = /* @__PURE__ */ function(Type) {
 	Type["ERC20"] = "erc20";
@@ -2413,7 +2211,7 @@ let Type = /* @__PURE__ */ function(Type) {
 * @param parameters - {@link from.Parameters}
 * @returns The created Position. {@link from.ReturnType}
 */
-function from$6(parameters) {
+function from$7(parameters) {
 	return {
 		chainId: parameters.chainId,
 		contract: parameters.contract.toLowerCase(),
@@ -2430,7 +2228,7 @@ function from$6(parameters) {
 var Quote_exports = /* @__PURE__ */ __exportAll({
 	InvalidQuoteError: () => InvalidQuoteError,
 	QuoteSchema: () => QuoteSchema,
-	from: () => from$5,
+	from: () => from$6,
 	fromSnakeCase: () => fromSnakeCase,
 	random: () => random
 });
@@ -2451,7 +2249,7 @@ const QuoteSchema = zod.object({
 * const quote = Quote.from({ obligationId: "0x123", ask: { price: 100n }, bid: { price: 100n } });
 * ```
 */
-function from$5(parameters) {
+function from$6(parameters) {
 	try {
 		const parsedQuote = QuoteSchema.parse(parameters);
 		return {
@@ -2470,7 +2268,7 @@ function from$5(parameters) {
 * @returns The created quote. {@link fromSnakeCase.ReturnType}
 */
 function fromSnakeCase(snake) {
-	return from$5(fromSnakeCase$3(snake));
+	return from$6(fromSnakeCase$3(snake));
 }
 /**
 * Generates a random quote.
@@ -2482,7 +2280,7 @@ function fromSnakeCase(snake) {
 * ```
 */
 function random() {
-	return from$5({
+	return from$6({
 		obligationId: id(random$2()),
 		ask: { price: BigInt(int(1e6)) },
 		bid: { price: BigInt(int(1e6)) }
@@ -2505,7 +2303,7 @@ var TradingFee_exports = /* @__PURE__ */ __exportAll({
 	activate: () => activate,
 	compute: () => compute,
 	deactivate: () => deactivate,
-	from: () => from$4,
+	from: () => from$5,
 	getFees: () => getFees,
 	isActivated: () => isActivated
 });
@@ -2531,7 +2329,7 @@ const WAD = 10n ** 18n;
 * @throws {@link InvalidFeeError} if any fee exceeds WAD (100%).
 * @throws {@link InvalidFeesLengthError} if fees array doesn't have exactly 6 elements.
 */
-function from$4(activated, fees) {
+function from$5(activated, fees) {
 	if (fees.length !== 6) throw new InvalidFeesLengthError(fees.length);
 	for (let i = 0; i < 6; i++) {
 		const fee = fees[i];
@@ -2643,33 +2441,364 @@ var InvalidFeesLengthError = class extends BaseError {
 		_defineProperty(this, "name", "TradingFee.InvalidFeesLengthError");
 	}
 };
-
-//#endregion
-//#region src/core/Transfer.ts
-var Transfer_exports = /* @__PURE__ */ __exportAll({ from: () => from$3 });
+
+//#endregion
+//#region src/core/Transfer.ts
+var Transfer_exports = /* @__PURE__ */ __exportAll({ from: () => from$4 });
+/**
+* @constructor
+*
+* Creates a {@link Transfer}.
+* @param parameters - {@link from.Parameters}
+* @returns The created Transfer. {@link from.ReturnType}
+*
+* @example
+* ```ts
+* const transfer = Transfer.from({ id: "1", chainId: 1, contract: "0x123", from: "0x456", to: "0x789", value: 100n, blockNumber: 100n });
+* ```
+*/
+function from$4(parameters) {
+	return {
+		id: parameters.id,
+		chainId: parameters.chainId,
+		contract: parameters.contract.toLowerCase(),
+		from: parameters.from.toLowerCase(),
+		to: parameters.to.toLowerCase(),
+		value: parameters.value,
+		blockNumber: parameters.blockNumber
+	};
+}
+
+//#endregion
+//#region src/core/Tree.ts
+var Tree_exports = /* @__PURE__ */ __exportAll({
+	DecodeError: () => DecodeError,
+	EncodeError: () => EncodeError,
+	SignatureDomainError: () => SignatureDomainError,
+	TreeError: () => TreeError,
+	VERSION: () => VERSION,
+	decode: () => decode,
+	encode: () => encode,
+	encodeUnsigned: () => encodeUnsigned,
+	from: () => from$3,
+	proofs: () => proofs,
+	signatureDomain: () => signatureDomain,
+	signatureTypes: () => signatureTypes
+});
+const VERSION = 1;
+/**
+* EIP-712 types for signing the tree root (Root(bytes32 root)).
+*/
+const signatureTypes = {
+	EIP712Domain: [{
+		name: "chainId",
+		type: "uint256"
+	}, {
+		name: "verifyingContract",
+		type: "address"
+	}],
+	Root: [{
+		name: "root",
+		type: "bytes32"
+	}]
+};
+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$3 = (offers) => {
+	const leaves = offers.map((offer) => [hash(offer)]);
+	const tree = _openzeppelin_merkle_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)])
+		};
+	});
+};
+/**
+* Normalizes a Root signature domain (BigInt chain id, lowercase address).
+* @throws {SignatureDomainError} When the domain is invalid.
+*/
+const signatureDomain = (domain) => {
+	return normalizeSignatureDomain(domain, (reason) => new SignatureDomainError(reason));
+};
+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 (!(0, viem.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" || !(0, viem.isHex)(value)) throw errorFactory(`${name} is not a valid hex string`);
+	if ((0, viem.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 = (0, viem.hashTypedData)({
+		domain,
+		types: signatureTypes,
+		primaryType: "Root",
+		message: { root }
+	});
+	try {
+		return await (0, viem.recoverAddress)({
+			hash,
+			signature
+		});
+	} catch {
+		throw errorFactory("signature recovery failed");
+	}
+};
+/**
+* Encodes a merkle tree with signature into hex calldata for onchain broadcast.
+*
+* Layout: `0x{vv}{gzip([...offers])}{root}{signature}` where:
+* - `{vv}`: 1-byte version (currently 0x01)
+* - `{gzip([...offers])}`: gzipped JSON array of serialized offers
+* - `{root}`: 32-byte merkle root
+* - `{signature}`: 65-byte EIP-712 signature over Root(bytes32 root)
+*
+* Validates signature authenticity and root integrity before encoding.
+*
+* @example
+* ```typescript
+* const tree = Tree.from(offers);
+* const signature = await wallet.signTypedData({
+*   account: wallet.account,
+*   domain: Tree.signatureDomain({ chainId, verifyingContract }),
+*   types: Tree.signatureTypes,
+*   primaryType: "Root",
+*   message: { root: tree.root },
+* });
+* const calldata = await Tree.encode(tree, signature, { chainId, verifyingContract });
+* await broadcast(calldata);
+* ```
+*
+* @example
+* Manual construction (for advanced users):
+* ```typescript
+* const tree = Tree.from(offers);
+* const compressed = gzip(JSON.stringify(tree.offers.map(Offer.serialize)));
+* const partial = `0x01${bytesToHex(compressed)}${tree.root.slice(2)}`;
+* const signature = await wallet.signTypedData({
+*   account: wallet.account,
+*   domain: Tree.signatureDomain({ chainId, verifyingContract }),
+*   types: Tree.signatureTypes,
+*   primaryType: "Root",
+*   message: { root: tree.root },
+* });
+* const calldata = `${partial}${signature.slice(2)}`;
+* ```
+*
+* @param tree - Merkle tree of offers
+* @param signature - EIP-712 signature over Root(bytes32 root)
+* @param domain - EIP-712 domain with chain id and verifying contract
+* @returns Hex-encoded calldata ready for onchain broadcast
+* @throws {EncodeError} If signature verification fails or root mismatch
+*/
+const encode = async (tree, signature, domain) => {
+	const errorFactory = (reason) => new EncodeError(reason);
+	const normalizedDomain = normalizeSignatureDomain(domain, errorFactory);
+	validateTreeForEncoding(tree, normalizedDomain);
+	await verifySignatureAndRecoverAddress({
+		root: tree.root,
+		signature,
+		domain: normalizedDomain,
+		errorFactory
+	});
+	const unsigned = encodeUnsignedBytes(tree);
+	const sigBytes = (0, viem.hexToBytes)(signature);
+	const encoded = new Uint8Array(unsigned.length + sigBytes.length);
+	encoded.set(unsigned, 0);
+	encoded.set(sigBytes, unsigned.length);
+	return (0, viem.bytesToHex)(encoded);
+};
+/**
+* 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 (0, viem.bytesToHex)(encodeUnsignedBytes(tree));
+};
+const validateTreeForEncoding = (tree, domain) => {
+	if (VERSION > 255) throw new EncodeError(`version overflow: ${VERSION} exceeds 255`);
+	const computed = from$3(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 = (0, pako.gzip)(JSON.stringify(offersPayload));
+	const rootBytes = (0, viem.hexToBytes)(tree.root);
+	const encoded = new Uint8Array(1 + compressed.length + 32);
+	encoded[0] = VERSION;
+	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 = (0, viem.hexToBytes)(encoded);
+	if (bytes.length < 98) throw new DecodeError("payload too short");
+	const version = bytes[0];
+	if (version !== (VERSION & 255)) throw new DecodeError(`invalid version: expected ${VERSION}, got ${version ?? 0}`);
+	const signature = (0, viem.bytesToHex)(bytes.slice(-65));
+	const root = (0, viem.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 = (0, pako.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$3(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 {
+	constructor(reason) {
+		super(`Tree error: ${reason}`);
+		_defineProperty(this, "name", "Tree.TreeError");
+	}
+};
+/**
+* Error thrown during tree encoding.
+* Indicates validation failures (signature, root mismatch, mixed makers).
+*/
+var EncodeError = class extends BaseError {
+	constructor(reason) {
+		super(`Failed to encode tree: ${reason}`);
+		_defineProperty(this, "name", "Tree.EncodeError");
+	}
+};
 /**
-* @constructor
-*
-* Creates a {@link Transfer}.
-* @param parameters - {@link from.Parameters}
-* @returns The created Transfer. {@link from.ReturnType}
-*
-* @example
-* ```ts
-* const transfer = Transfer.from({ id: "1", chainId: 1, contract: "0x123", from: "0x456", to: "0x789", value: 100n, blockNumber: 100n });
-* ```
+* Error thrown during tree decoding.
+* Indicates payload corruption, version mismatch, or validation failures.
 */
-function from$3(parameters) {
-	return {
-		id: parameters.id,
-		chainId: parameters.chainId,
-		contract: parameters.contract.toLowerCase(),
-		from: parameters.from.toLowerCase(),
-		to: parameters.to.toLowerCase(),
-		value: parameters.value,
-		blockNumber: parameters.blockNumber
-	};
-}
+var DecodeError = class extends BaseError {
+	constructor(reason) {
+		super(`Failed to decode tree: ${reason}`);
+		_defineProperty(this, "name", "Tree.DecodeError");
+	}
+};
+/**
+* Error thrown when an invalid signature domain is supplied.
+*/
+var SignatureDomainError = class extends BaseError {
+	constructor(reason) {
+		super(`Invalid signature domain: ${reason}`);
+		_defineProperty(this, "name", "Tree.SignatureDomainError");
+	}
+};
 
 //#endregion
 //#region src/core/types.ts
@@ -2836,6 +2965,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,
@@ -2904,6 +3048,55 @@ __decorate([(0, openapi_metadata_decorators.ApiProperty)({
 	type: "string",
 	example: validateOfferExample.callback.data
 })], ValidateCallbackRequest.prototype, "data", void 0);
+var CallbackTypesChainRequest = class {};
+__decorate([(0, openapi_metadata_decorators.ApiProperty)({
+	type: "number",
+	example: callbackTypesRequestExample.callbacks[0].chain_id
+})], CallbackTypesChainRequest.prototype, "chain_id", void 0);
+__decorate([(0, openapi_metadata_decorators.ApiProperty)({
+	type: () => [String],
+	example: callbackTypesRequestExample.callbacks[0].addresses
+})], CallbackTypesChainRequest.prototype, "addresses", void 0);
+var CallbackTypesRequest = class {};
+__decorate([(0, openapi_metadata_decorators.ApiProperty)({
+	type: () => [CallbackTypesChainRequest],
+	example: callbackTypesRequestExample.callbacks
+})], CallbackTypesRequest.prototype, "callbacks", void 0);
+var CallbackTypesChainResponse = class {};
+__decorate([(0, openapi_metadata_decorators.ApiProperty)({
+	type: "number",
+	example: callbackTypesResponseExample[0].chain_id
+})], CallbackTypesChainResponse.prototype, "chain_id", void 0);
+__decorate([(0, openapi_metadata_decorators.ApiProperty)({
+	type: () => [String],
+	required: false,
+	example: callbackTypesResponseExample[0].buy_vault_v1_callback
+})], CallbackTypesChainResponse.prototype, "buy_vault_v1_callback", void 0);
+__decorate([(0, openapi_metadata_decorators.ApiProperty)({
+	type: () => [String],
+	required: false,
+	example: callbackTypesResponseExample[0].sell_erc20_callback
+})], CallbackTypesChainResponse.prototype, "sell_erc20_callback", void 0);
+__decorate([(0, openapi_metadata_decorators.ApiProperty)({
+	type: () => [String],
+	required: false,
+	example: callbackTypesResponseExample[0].buy_erc20
+})], CallbackTypesChainResponse.prototype, "buy_erc20", void 0);
+__decorate([(0, openapi_metadata_decorators.ApiProperty)({
+	type: () => [String],
+	example: callbackTypesResponseExample[0].not_supported
+})], CallbackTypesChainResponse.prototype, "not_supported", void 0);
+var CallbackTypesSuccessResponse = class extends SuccessResponse {};
+__decorate([(0, openapi_metadata_decorators.ApiProperty)({
+	type: "string",
+	nullable: true,
+	example: "maturity:1:1730415600:end_of_next_month"
+})], CallbackTypesSuccessResponse.prototype, "cursor", void 0);
+__decorate([(0, openapi_metadata_decorators.ApiProperty)({
+	type: () => [CallbackTypesChainResponse],
+	description: "Callback types grouped by chain.",
+	example: callbackTypesResponseExample
+})], CallbackTypesSuccessResponse.prototype, "data", void 0);
 var AskResponse = class {};
 __decorate([(0, openapi_metadata_decorators.ApiProperty)({
 	type: "string",
@@ -3439,6 +3632,28 @@ ValidateController = __decorate([(0, openapi_metadata_decorators.ApiTags)("Make"
 	description: "Bad Request",
 	type: BadRequestResponse
 })], ValidateController);
+let CallbacksController = class CallbacksController {
+	async resolveCallbackTypes() {}
+};
+__decorate([
+	(0, openapi_metadata_decorators.ApiOperation)({
+		methods: ["post"],
+		path: "/v1/callbacks",
+		summary: "Resolve callback types",
+		description: "Returns callback types for callback addresses grouped by chain."
+	}),
+	(0, openapi_metadata_decorators.ApiBody)({ type: CallbackTypesRequest }),
+	(0, openapi_metadata_decorators.ApiResponse)({
+		status: 200,
+		description: "Success",
+		type: CallbackTypesSuccessResponse
+	})
+], CallbacksController.prototype, "resolveCallbackTypes", null);
+CallbacksController = __decorate([(0, openapi_metadata_decorators.ApiTags)("Make"), (0, openapi_metadata_decorators.ApiResponse)({
+	status: 400,
+	description: "Bad Request",
+	type: BadRequestResponse
+})], CallbacksController);
 let OffersController = class OffersController {
 	async getOffers() {}
 };
@@ -3560,54 +3775,221 @@ __decorate([
 	})
 ], HealthController.prototype, "getChainsHealth", null);
 HealthController = __decorate([(0, openapi_metadata_decorators.ApiTags)("System")], HealthController);
-const callbacksExample = [Type$1.BuyWithEmptyCallback];
-const chainConfigExample = {
+const configContractsExample = {
 	chain_id: 505050505,
-	contracts: { mempool: "0xD946246695A9259F3B33a78629026F61B3Ab40aF" },
-	callbacks: callbacksExample
+	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"
 };
-var ConfigContractsResponse = class {};
+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([(0, openapi_metadata_decorators.ApiProperty)({
+	type: "number",
+	example: configContractsExample.chain_id
+})], ConfigContractResponse.prototype, "chain_id", void 0);
+__decorate([(0, openapi_metadata_decorators.ApiProperty)({
+	type: "string",
+	example: configContractsExample.address
+})], ConfigContractResponse.prototype, "address", void 0);
+__decorate([(0, openapi_metadata_decorators.ApiProperty)({
+	type: "string",
+	enum: configContractNames,
+	example: configContractsExample.name
+})], ConfigContractResponse.prototype, "name", void 0);
+var ConfigContractsSuccessResponse = class extends SuccessResponse {};
+__decorate([(0, openapi_metadata_decorators.ApiProperty)({
+	type: "string",
+	nullable: true,
+	example: null
+})], ConfigContractsSuccessResponse.prototype, "cursor", void 0);
+__decorate([(0, openapi_metadata_decorators.ApiProperty)({
+	type: () => [ConfigContractResponse],
+	description: "Indexer contract configuration for all indexed chains.",
+	example: configContractsPayloadExample
+})], ConfigContractsSuccessResponse.prototype, "data", void 0);
+var ConfigRulesMeta = class {};
+__decorate([(0, openapi_metadata_decorators.ApiProperty)({
+	type: "string",
+	example: timestampExample
+})], ConfigRulesMeta.prototype, "timestamp", void 0);
+__decorate([(0, openapi_metadata_decorators.ApiProperty)({
+	type: "string",
+	example: configRulesChecksumExample
+})], ConfigRulesMeta.prototype, "checksum", void 0);
+var ConfigRulesRuleResponse = class {};
 __decorate([(0, openapi_metadata_decorators.ApiProperty)({
 	type: "string",
-	example: chainConfigExample.contracts.mempool
-})], ConfigContractsResponse.prototype, "mempool", void 0);
-var ConfigDataResponse = class {};
+	example: configRulesMaturityExample.type
+})], ConfigRulesRuleResponse.prototype, "type", void 0);
 __decorate([(0, openapi_metadata_decorators.ApiProperty)({
 	type: "number",
-	example: chainConfigExample.chain_id
-})], ConfigDataResponse.prototype, "chain_id", void 0);
-__decorate([(0, openapi_metadata_decorators.ApiProperty)({ type: () => ConfigContractsResponse })], ConfigDataResponse.prototype, "contracts", void 0);
+	example: configRulesMaturityExample.chain_id
+})], ConfigRulesRuleResponse.prototype, "chain_id", void 0);
 __decorate([(0, openapi_metadata_decorators.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 {};
+	type: "string",
+	example: configRulesMaturityExample.name,
+	required: false
+})], ConfigRulesRuleResponse.prototype, "name", void 0);
+__decorate([(0, openapi_metadata_decorators.ApiProperty)({
+	type: "number",
+	example: configRulesMaturityExample.timestamp,
+	required: false
+})], ConfigRulesRuleResponse.prototype, "timestamp", void 0);
+__decorate([(0, openapi_metadata_decorators.ApiProperty)({
+	type: "string",
+	example: configRulesCallbackExample.address,
+	required: false
+})], ConfigRulesRuleResponse.prototype, "address", void 0);
+__decorate([(0, openapi_metadata_decorators.ApiProperty)({
+	type: "string",
+	example: configRulesCallbackExample.callback_type,
+	required: false
+})], ConfigRulesRuleResponse.prototype, "callback_type", void 0);
+var ConfigRulesSuccessResponse = class {};
+__decorate([(0, openapi_metadata_decorators.ApiProperty)({ type: () => ConfigRulesMeta })], ConfigRulesSuccessResponse.prototype, "meta", void 0);
 __decorate([(0, openapi_metadata_decorators.ApiProperty)({
 	type: "string",
 	nullable: true,
 	example: null
-})], ConfigSuccessResponse.prototype, "cursor", void 0);
-__decorate([(0, openapi_metadata_decorators.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() {}
+})], ConfigRulesSuccessResponse.prototype, "cursor", void 0);
+__decorate([(0, openapi_metadata_decorators.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([
+	(0, openapi_metadata_decorators.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."
+	}),
+	(0, openapi_metadata_decorators.ApiQuery)({
+		name: "cursor",
+		type: "string",
+		required: false,
+		example: configContractsCursorExample,
+		description: "Pagination cursor in chain_id:address format (lowercase address)."
+	}),
+	(0, openapi_metadata_decorators.ApiQuery)({
+		name: "limit",
+		type: "number",
+		required: false,
+		example: 1e3,
+		description: "Maximum number of contracts to return (max 1000)."
+	}),
+	(0, openapi_metadata_decorators.ApiQuery)({
+		name: "chains",
+		type: ["number"],
+		required: false,
+		example: "1,8453",
+		description: "Filter by chain IDs (comma-separated).",
+		style: "form",
+		explode: false
+	}),
+	(0, openapi_metadata_decorators.ApiResponse)({
+		status: 200,
+		description: "Success",
+		type: ConfigContractsSuccessResponse
+	})
+], ConfigContractsController.prototype, "getConfigContracts", null);
+ConfigContractsController = __decorate([(0, openapi_metadata_decorators.ApiTags)("System")], ConfigContractsController);
+let ConfigRulesController = class ConfigRulesController {
+	async getConfigRules() {}
 };
-__decorate([(0, openapi_metadata_decorators.ApiOperation)({
-	methods: ["get"],
-	path: "/v1/config",
-	summary: "Get router configuration",
-	description: "Returns chain configurations including contract addresses and supported callback types."
-}), (0, openapi_metadata_decorators.ApiResponse)({
-	status: 200,
-	description: "Success",
-	type: ConfigSuccessResponse
-})], ConfigController.prototype, "getConfig", null);
-ConfigController = __decorate([(0, openapi_metadata_decorators.ApiTags)("System")], ConfigController);
+__decorate([
+	(0, openapi_metadata_decorators.ApiOperation)({
+		methods: ["get"],
+		path: "/v1/config/rules",
+		summary: "Get config rules",
+		description: "Returns configured rules for supported chains."
+	}),
+	(0, openapi_metadata_decorators.ApiQuery)({
+		name: "cursor",
+		type: "string",
+		required: false,
+		example: "maturity:1:1730415600:end_of_next_month",
+		description: "Pagination cursor in type:chain_id:<value> format."
+	}),
+	(0, openapi_metadata_decorators.ApiQuery)({
+		name: "limit",
+		type: "number",
+		required: false,
+		example: 100,
+		description: "Maximum number of rules to return (max 1000)."
+	}),
+	(0, openapi_metadata_decorators.ApiQuery)({
+		name: "types",
+		type: ["string"],
+		required: false,
+		example: "maturity,loan_token",
+		description: "Filter by rule types (comma-separated).",
+		style: "form",
+		explode: false
+	}),
+	(0, openapi_metadata_decorators.ApiQuery)({
+		name: "chains",
+		type: ["number"],
+		required: false,
+		example: "1,8453",
+		description: "Filter by chain IDs (comma-separated).",
+		style: "form",
+		explode: false
+	}),
+	(0, openapi_metadata_decorators.ApiResponse)({
+		status: 200,
+		description: "Success",
+		type: ConfigRulesSuccessResponse
+	})
+], ConfigRulesController.prototype, "getConfigRules", null);
+ConfigRulesController = __decorate([(0, openapi_metadata_decorators.ApiTags)("System")], ConfigRulesController);
 let ObligationsController = class ObligationsController {
 	async getObligations() {}
 	async getObligation() {}
@@ -3736,16 +4118,18 @@ UsersController = __decorate([(0, openapi_metadata_decorators.ApiTags)("Make"),
 	description: "Bad Request",
 	type: BadRequestResponse
 })], UsersController);
-const OpenApi = async (options = {}) => {
-	const document = await (0, openapi_metadata.generateDocument)({
+const OpenApi = async () => {
+	return await (0, openapi_metadata.generateDocument)({
 		controllers: [
 			BooksController,
-			ConfigController,
+			ConfigContractsController,
+			ConfigRulesController,
 			OffersController,
 			ObligationsController,
 			HealthController,
 			UsersController,
-			ValidateController
+			ValidateController,
+			CallbacksController
 		],
 		document: {
 			openapi: "3.1.0",
@@ -3777,12 +4161,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
@@ -3807,6 +4185,10 @@ function from$1(position) {
 //#region src/api/Schema/requests.ts
 const MAX_LIMIT = 100;
 const DEFAULT_LIMIT = 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) {
@@ -3840,6 +4222,43 @@ const PaginationQueryParams = zod.object({
 		example: 10
 	})
 });
+const ConfigRuleTypes = zod.enum([
+	"maturity",
+	"callback",
+	"loan_token"
+]);
+const GetConfigRulesQueryParams = zod.object({
+	cursor: zod.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: zod.string().regex(/^[1-9]\d*$/, { message: "Limit must be a positive integer" }).transform((val) => Number.parseInt(val, 10)).pipe(zod.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(zod.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 = zod.object({
+	cursor: zod.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: zod.string().regex(/^[1-9]\d*$/, { message: "Limit must be a positive integer" }).transform((val) => Number.parseInt(val, 10)).pipe(zod.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(zod.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 = zod.object({
 	...PaginationQueryParams.shape,
 	side: zod.enum(["buy", "sell"]).optional().meta({
@@ -3942,6 +4361,16 @@ const GetBookParams = zod.object({
 	})
 });
 const ValidateOffersBody = zod.object({ offers: zod.array(zod.unknown()).min(1, { message: "'offers' must contain at least 1 offer" }) }).strict();
+const CallbackTypesBody = zod.object({ callbacks: zod.array(zod.object({
+	chain_id: zod.number().int().positive().meta({
+		description: "Chain id.",
+		example: 1
+	}),
+	addresses: zod.array(zod.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 = zod.object({
 	...PaginationQueryParams.shape,
 	user_address: zod.string().regex(/^0x[a-fA-F0-9]{40}$/, { error: "User address must be a valid 20-byte address" }).transform((val) => val.toLowerCase()).meta({
@@ -3953,11 +4382,14 @@ 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 parse(action, query) {
@@ -3972,11 +4404,13 @@ function safeParse(action, query, error) {
 var Schema_exports = /* @__PURE__ */ __exportAll({
 	BookResponse: () => BookResponse_exports,
 	BooksController: () => BooksController,
+	CallbacksController: () => CallbacksController,
 	ChainHealth: () => ChainHealth,
 	ChainsHealthResponse: () => ChainsHealthResponse,
 	CollectorHealth: () => CollectorHealth,
 	CollectorsHealthResponse: () => CollectorsHealthResponse,
-	ConfigController: () => ConfigController,
+	ConfigContractsController: () => ConfigContractsController,
+	ConfigRulesController: () => ConfigRulesController,
 	HealthController: () => HealthController,
 	ObligationResponse: () => ObligationResponse_exports,
 	ObligationsController: () => ObligationsController,
@@ -4182,12 +4616,14 @@ 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 {
@@ -4206,12 +4642,20 @@ function createHttpClient(config) {
 			body: json
 		};
 	};
-	const getRules = async () => {
-		const response = await request("/v1/rules", { method: "GET" });
+	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();
-		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;
+		return {
+			statusCode: response.status,
+			body: json
+		};
 	};
 	const isAllowed = async (offers) => {
 		const { statusCode, body } = await validate({ offers: offers.map((offer) => toSnakeCase(offer)) });
@@ -4239,13 +4683,31 @@ function createHttpClient(config) {
 			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,
-		getRules
+		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(/\/+$/, "");
 }
@@ -4341,16 +4803,26 @@ async function run(parameters) {
 	};
 }
 
+//#endregion
+//#region src/gatekeeper/Gatekeeper.ts
+var Gatekeeper_exports = /* @__PURE__ */ __exportAll({ create: () => create });
+/**
+* Create a gatekeeper instance with the provided rules.
+* @param parameters - Gatekeeper parameters. {@link GatekeeperParameters}
+* @returns Gatekeeper instance. {@link Gatekeeper}
+*/
+function create(parameters) {
+	const { rules } = parameters;
+	return { isAllowed: async (offers) => {
+		return await run({
+			items: offers,
+			rules
+		});
+	} };
+}
+
 //#endregion
 //#region src/gatekeeper/GateConfig.ts
-var GateConfig_exports = /* @__PURE__ */ __exportAll({
-	assets: () => assets,
-	configs: () => configs,
-	getCallback: () => getCallback,
-	getCallbackAddresses: () => getCallbackAddresses,
-	getCallbackType: () => getCallbackType,
-	getCallbackTypeAddresses: () => getCallbackTypeAddresses
-});
 /**
 * Returns the callback configuration for a given chain and callback type, if it exists.
 *
@@ -4373,17 +4845,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
@@ -4482,30 +4943,6 @@ const configs = {
 	}
 };
 
-//#endregion
-//#region src/gatekeeper/Gatekeeper.ts
-var Gatekeeper_exports = /* @__PURE__ */ __exportAll({ create: () => create });
-/**
-* Create a gatekeeper instance with the provided rules.
-* @param parameters - Gatekeeper parameters. {@link GatekeeperParameters}
-* @returns Gatekeeper instance. {@link Gatekeeper}
-*/
-function create(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
-		}))
-	};
-}
-
 //#endregion
 //#region src/gatekeeper/Rules.ts
 var Rules_exports = /* @__PURE__ */ __exportAll({
@@ -4706,6 +5143,7 @@ function from(parameters) {
 	const config = {
 		client: parameters.client,
 		mempoolAddress: parameters.mempoolAddress,
+		morphoAddress: parameters.morphoAddress,
 		blockWindow: parameters.blockWindow
 	};
 	return {
@@ -4723,11 +5161,18 @@ function from(parameters) {
 */
 async function add(config, offers) {
 	if (!config.client.account) throw new WalletAccountNotSetError();
-	const tree = from$9(offers.map((o) => from$8(o)));
+	const tree = from$3(offers.map((o) => from$9(o)));
 	const chainId = await getChainId(config.client);
 	for (const offer of tree.offers) if (chainId !== offer.chainId) throw new ChainIdMismatchError(offer.chainId, chainId);
-	const signature = await sign(tree.offers, config.client);
-	const encoded = await encode$1(tree, signature);
+	const signatureDomain$1 = resolveSignatureDomain(config, chainId);
+	const signature = await config.client.signTypedData({
+		account: config.client.account,
+		domain: signatureDomain(signatureDomain$1),
+		types: signatureTypes,
+		primaryType: "Root",
+		message: { root: tree.root }
+	});
+	const encoded = await encode(tree, signature, signatureDomain$1);
 	try {
 		return await config.client.sendTransaction({
 			chain: config.client.chain,
@@ -4766,6 +5211,7 @@ const getChainId = async (client) => {
 };
 async function* streamOffers(config, parameters) {
 	const { loanToken, blockNumberGte, blockNumberLte, order = "desc", options: { maxBatchSize = DEFAULT_BATCH_SIZE, blockWindow = config.blockWindow } = {} } = parameters;
+	const signatureDomain = resolveSignatureDomain(config, await getChainId(config.client));
 	const stream = streamLogs({
 		client: config.client.extend(viem.publicActions),
 		contractAddress: config.mempoolAddress,
@@ -4797,7 +5243,7 @@ async function* streamOffers(config, parameters) {
 			if (!log) continue;
 			const [payload] = (0, viem.decodeAbiParameters)([{ type: "bytes" }], log.data);
 			try {
-				const { tree } = await decode$1(payload);
+				const { tree } = await decode(payload, signatureDomain);
 				for (const offer of tree.offers) {
 					if (loanToken && offer.loanToken.toLowerCase() !== loanToken.toLowerCase()) continue;
 					offers.push(offer);
@@ -4832,6 +5278,21 @@ var ChainIdMismatchError = class extends BaseError {
 		_defineProperty(this, "name", "Mempool.ChainIdMismatchError");
 	}
 };
+const resolveSignatureDomain = (config, chainId) => {
+	const chain = config.client.chain;
+	const verifyingContract = config.morphoAddress ?? chain?.custom?.morpho?.address ?? getChain(chainId)?.custom.morpho.address;
+	if (!verifyingContract || verifyingContract.toLowerCase() === viem.zeroAddress) throw new MissingMorphoAddressError();
+	return {
+		chainId,
+		verifyingContract
+	};
+};
+var MissingMorphoAddressError = class extends BaseError {
+	constructor() {
+		super("Morpho address is required to verify root signatures (zero address is invalid).");
+		_defineProperty(this, "name", "Mempool.MissingMorphoAddressError");
+	}
+};
 
 //#endregion
 //#region src/mempool/MempoolClient.ts
@@ -5045,12 +5506,6 @@ Object.defineProperty(exports, 'Format', {
     return Format_exports;
   }
 });
-Object.defineProperty(exports, 'GateConfig', {
-  enumerable: true,
-  get: function () {
-    return GateConfig_exports;
-  }
-});
 Object.defineProperty(exports, 'Gatekeeper', {
   enumerable: true,
   get: function () {