@morpho-dev/router 0.2.1 → 0.3.0

package/dist/index.browser.js

@@ -41,7 +41,6 @@ let openapi_fetch = require("openapi-fetch");
 openapi_fetch = __toESM(openapi_fetch);
 let viem_actions = require("viem/actions");
 let viem_chains = require("viem/chains");
-let viem_accounts = require("viem/accounts");
 let __openzeppelin_merkle_tree = require("@openzeppelin/merkle-tree");
 let pako = require("pako");
 
@@ -149,13 +148,16 @@ var OfferResponse_exports = /* @__PURE__ */ __export({ from: () => from$11 });
 * Creates an `OfferResponse` from an `Offer`.
 * @constructor
 * @param offer - {@link Offer}
+* @param attestation - {@link Attestation}
 * @returns The created `OfferResponse`. {@link OfferResponse}
 */
-function from$11(offer) {
-	const result = toSnakeCase$1(offer);
+function from$11(offer, attestation) {
+	const { signature: _, ...rest } = toSnakeCase$1(offer);
 	return {
-		...result,
-		signature: result.signature ?? null
+		...rest,
+		root: attestation?.root.toLowerCase() ?? null,
+		proof: attestation?.proof.map((p) => p.toLowerCase()) ?? null,
+		signature: attestation?.signature.toLowerCase() ?? null
 	};
 }
 
@@ -204,10 +206,12 @@ const offerExample = {
 		data: "0x00000000000000000000000000000000000000000000000000000000000000400000000000000000000000000000000000000000000000000000000000000080000000000000000000000000000000000000000000000000000000000000000100000000000000000000000034cf890db685fc536e05652fb41f02090c3fb751000000000000000000000000000000000000000000000000000000000000000100000000000000000000000000108e644e3ab01184155270aa92a00000000000",
 		gas_limit: "500000"
 	},
-	signature: "0x1234567890123456789012345678901234567890123456789012345678901234123456789012345678901234567890123456789012345678901234567890123400",
 	consumed: "0",
 	takeable: "369216000000000000000000",
-	block_number: 0xa7495128adfb1
+	block_number: 0xa7495128adfb1,
+	root: "0x1234567890abcdef1234567890abcdef1234567890abcdef1234567890abcdef",
+	proof: ["0xabcdef1234567890abcdef1234567890abcdef1234567890abcdef1234567890", "0x9876543210fedcba9876543210fedcba9876543210fedcba9876543210fedcba"],
+	signature: "0x1234567890123456789012345678901234567890123456789012345678901234123456789012345678901234567890123456789012345678901234567890123400"
 };
 const collectorsHealthExample = {
 	name: "offers",
@@ -352,6 +356,16 @@ __decorate([(0, openapi_metadata_decorators.ApiProperty)({
 	type: "number",
 	example: offerExample.block_number
 })], OfferListItemResponse.prototype, "block_number", void 0);
+__decorate([(0, openapi_metadata_decorators.ApiProperty)({
+	type: "string",
+	nullable: true,
+	example: offerExample.root
+})], OfferListItemResponse.prototype, "root", void 0);
+__decorate([(0, openapi_metadata_decorators.ApiProperty)({
+	type: [String],
+	nullable: true,
+	example: offerExample.proof
+})], OfferListItemResponse.prototype, "proof", void 0);
 __decorate([(0, openapi_metadata_decorators.ApiProperty)({
 	type: "string",
 	nullable: true,
@@ -535,44 +549,61 @@ __decorate([(0, openapi_metadata_decorators.ApiProperty)({
 var ValidateOffersRequest = class {};
 __decorate([(0, openapi_metadata_decorators.ApiProperty)({
 	type: () => [ValidateOfferRequest],
-	description: "Array of offers in snake_case format. Mutually exclusive with 'calldata'.",
-	required: false
+	description: "Array of offers in snake_case format. Required, non-empty.",
+	required: true
 })], ValidateOffersRequest.prototype, "offers", void 0);
+var ValidationSuccessDataResponse = class {};
 __decorate([(0, openapi_metadata_decorators.ApiProperty)({
 	type: "string",
-	description: "Encoded tree calldata as a hex string (0x-prefixed). Mutually exclusive with 'offers'.",
-	example: "0x01...",
-	required: false
-})], ValidateOffersRequest.prototype, "calldata", void 0);
-var ValidateOfferResultResponse = class {};
+	description: "Unsigned payload: version (1B) + gzip(offers) + root (32B).",
+	example: "0x01789c..."
+})], ValidationSuccessDataResponse.prototype, "payload", void 0);
 __decorate([(0, openapi_metadata_decorators.ApiProperty)({
 	type: "string",
-	example: offerExample.hash
-})], ValidateOfferResultResponse.prototype, "offer_hash", void 0);
+	description: "Merkle tree root to sign with EIP-191.",
+	example: "0xac4bd8318ec914f89f8af913f162230575b0ac0696a19256bc12138c5cfe1427"
+})], ValidationSuccessDataResponse.prototype, "root", void 0);
+var ValidationSuccessResponse = class extends SuccessResponse {};
 __decorate([(0, openapi_metadata_decorators.ApiProperty)({
-	type: "boolean",
-	example: false
-})], ValidateOfferResultResponse.prototype, "valid", void 0);
+	type: "string",
+	nullable: true,
+	example: null
+})], ValidationSuccessResponse.prototype, "cursor", void 0);
+__decorate([(0, openapi_metadata_decorators.ApiProperty)({
+	type: () => ValidationSuccessDataResponse,
+	description: "Payload and root for client-side signing."
+})], ValidationSuccessResponse.prototype, "data", void 0);
+var ValidationIssueResponse = class {};
+__decorate([(0, openapi_metadata_decorators.ApiProperty)({
+	type: "number",
+	description: "0-indexed position of the failed offer in the request array.",
+	example: 0
+})], ValidationIssueResponse.prototype, "index", void 0);
 __decorate([(0, openapi_metadata_decorators.ApiProperty)({
 	type: "string",
-	example: "parse_error",
-	nullable: true
-})], ValidateOfferResultResponse.prototype, "rule", void 0);
+	description: "Gatekeeper rule name that rejected the offer.",
+	example: "no_buy"
+})], ValidationIssueResponse.prototype, "rule", void 0);
 __decorate([(0, openapi_metadata_decorators.ApiProperty)({
 	type: "string",
-	example: "Invalid offer. 'offering': invalid address",
-	nullable: true
-})], ValidateOfferResultResponse.prototype, "message", void 0);
-var ValidateOffersListResponse = class extends SuccessResponse {};
+	description: "Human-readable rejection reason.",
+	example: "Buy offers are not supported"
+})], ValidationIssueResponse.prototype, "message", void 0);
+var ValidationFailureDataResponse = class {};
+__decorate([(0, openapi_metadata_decorators.ApiProperty)({
+	type: () => [ValidationIssueResponse],
+	description: "List of validation issues. Returned when any offer fails validation."
+})], ValidationFailureDataResponse.prototype, "issues", void 0);
+var ValidationFailureResponse = class extends SuccessResponse {};
 __decorate([(0, openapi_metadata_decorators.ApiProperty)({
 	type: "string",
 	nullable: true,
 	example: null
-})], ValidateOffersListResponse.prototype, "cursor", void 0);
+})], ValidationFailureResponse.prototype, "cursor", void 0);
 __decorate([(0, openapi_metadata_decorators.ApiProperty)({
-	type: () => [ValidateOfferResultResponse],
-	description: "Validation results for each offer."
-})], ValidateOffersListResponse.prototype, "data", void 0);
+	type: () => ValidationFailureDataResponse,
+	description: "List of validation issues. Returned when any offer fails validation."
+})], ValidationFailureResponse.prototype, "data", void 0);
 var BookLevelResponse = class {};
 __decorate([(0, openapi_metadata_decorators.ApiProperty)({
 	type: "string",
@@ -637,13 +668,18 @@ __decorate([
 		methods: ["post"],
 		path: "/v1/validate",
 		summary: "Validate offers",
-		description: "Validates offers against router validation rules. Returns validation status for each offer. Accepts either an array of offers or encoded calldata (mutually exclusive)."
+		description: "Validates offers against router validation rules. Returns unsigned payload + root on success, or issues only on validation failure."
 	}),
 	(0, openapi_metadata_decorators.ApiBody)({ type: ValidateOffersRequest }),
 	(0, openapi_metadata_decorators.ApiResponse)({
 		status: 200,
 		description: "Success",
-		type: ValidateOffersListResponse
+		type: ValidationSuccessResponse
+	}),
+	(0, openapi_metadata_decorators.ApiResponse)({
+		status: 200,
+		description: "Validation issues",
+		type: ValidationFailureResponse
 	})
 ], ValidateController.prototype, "validateOffers", null);
 ValidateController = __decorate([(0, openapi_metadata_decorators.ApiTags)("Validate"), (0, openapi_metadata_decorators.ApiResponse)({
@@ -812,7 +848,7 @@ const OpenApi = async (options = {}) => {
 	if (options.rules && options.rules.length > 0) {
 		const rulesDescription = options.rules.map((rule) => `- **${rule.name}**: ${rule.description}`).join("\n");
 		const validatePath = document.paths?.["/v1/validate"];
-		if (validatePath && "post" in validatePath && validatePath.post) validatePath.post.description = `Validates offers against router validation rules. Returns validation status for each offer.\n\n**Available validation rules:**\n${rulesDescription}`;
+		if (validatePath && "post" in validatePath && validatePath.post) validatePath.post.description = `Validates offers against router validation rules. Returns unsigned payload + root on success, or issues only on validation failure.\n\n**Available validation rules:**\n${rulesDescription}`;
 	}
 	return document;
 };
@@ -824,17 +860,23 @@ var Cursor_exports = /* @__PURE__ */ __export({
 	encode: () => encode$3,
 	validate: () => validate
 });
-function validate(cursor) {
-	if (!cursor || typeof cursor !== "object") throw new Error("Cursor must be an object");
-	const c = cursor;
-	if (![
+const isSort = (value) => {
+	return [
 		"rate",
 		"maturity",
 		"expiry",
 		"amount"
-	].includes(c.sort)) throw new Error(`Invalid sort field: ${c.sort}. Must be one of: rate, maturity, expiry, amount`);
-	if (!["asc", "desc"].includes(c.dir)) throw new Error(`Invalid direction: ${c.dir}. Must be one of: asc, desc`);
-	if (!/^0x[a-fA-F0-9]{64}$/.test(c.hash)) throw new Error(`Invalid hash format: ${c.hash}. Must be a 64-character hex string starting with 0x`);
+	].includes(value);
+};
+function validate(cursor) {
+	if (!cursor || typeof cursor !== "object") throw new Error("Cursor must be an object");
+	const c = cursor;
+	const sort = c.sort;
+	const dir = c.dir;
+	const hash$1 = c.hash;
+	if (typeof sort !== "string" || !isSort(sort)) throw new Error(`Invalid sort field: ${String(sort)}. Must be one of: rate, maturity, expiry, amount`);
+	if (typeof dir !== "string" || !["asc", "desc"].includes(dir)) throw new Error(`Invalid direction: ${String(dir)}. Must be one of: asc, desc`);
+	if (typeof hash$1 !== "string" || !/^0x[a-fA-F0-9]{64}$/.test(hash$1)) throw new Error(`Invalid hash format: ${String(hash$1)}. Must be a 64-character hex string starting with 0x`);
 	const validation = {
 		rate: {
 			field: "rate",
@@ -851,24 +893,30 @@ function validate(cursor) {
 		maturity: {
 			field: "maturity",
 			type: "number",
-			validator: (val) => val > 0,
+			min: 1,
 			error: "positive number"
 		},
 		expiry: {
 			field: "expiry",
 			type: "number",
-			validator: (val) => val > 0,
+			min: 1,
 			error: "positive number"
 		}
-	}[c.sort];
-	if (!validation) throw new Error(`Invalid sort field: ${c.sort}`);
+	}[sort];
+	if (!validation) throw new Error(`Invalid sort field: ${sort}`);
 	const fieldValue = c[validation.field];
-	if (!fieldValue) throw new Error(`${c.sort} sort requires '${validation.field}' field to be present`);
-	if (typeof fieldValue !== validation.type) throw new Error(`${c.sort} sort requires '${validation.field}' field of type ${validation.type}`);
-	if (validation.pattern && !validation.pattern.test(fieldValue)) throw new Error(`Invalid ${validation.field} format: ${fieldValue}. Must be a ${validation.error}`);
-	if (validation.validator && !validation.validator(fieldValue)) throw new Error(`Invalid ${validation.field} value: ${fieldValue}. Must be a ${validation.error}`);
-	if (c.page !== void 0) {
-		if (typeof c.page !== "number" || !Number.isInteger(c.page) || c.page < 1) throw new Error("Invalid page: must be a positive integer");
+	if (fieldValue === void 0 || fieldValue === null) throw new Error(`${sort} sort requires '${validation.field}' field to be present`);
+	if (validation.type === "string") {
+		if (typeof fieldValue !== "string") throw new Error(`${sort} sort requires '${validation.field}' field of type ${validation.type}`);
+		if (!validation.pattern.test(fieldValue)) throw new Error(`Invalid ${validation.field} format: ${fieldValue}. Must be a ${validation.error}`);
+	}
+	if (validation.type === "number") {
+		if (typeof fieldValue !== "number") throw new Error(`${sort} sort requires '${validation.field}' field of type ${validation.type}`);
+		if (fieldValue < validation.min) throw new Error(`Invalid ${validation.field} value: ${fieldValue}. Must be a ${validation.error}`);
+	}
+	const page = c.page;
+	if (page !== void 0) {
+		if (typeof page !== "number" || !Number.isInteger(page) || page < 1) throw new Error("Invalid page: must be a positive integer");
 	}
 	return true;
 }
@@ -984,21 +1032,7 @@ const schemas = {
 	get_obligations: GetObligationsQueryParams,
 	get_obligation: GetObligationParams,
 	get_book: GetBookParams,
-	validate_offers: zod.object({
-		offers: zod.any().refine((val) => val === void 0 || Array.isArray(val), { message: "'offers' must be an array" }),
-		calldata: zod.string().regex(/^0x[a-fA-F0-9]*$/, { message: "'calldata' must be a hex string starting with '0x'" }).optional()
-	}).superRefine((val, ctx) => {
-		const hasOffers = val.offers !== void 0;
-		const hasCalldata = val.calldata !== void 0;
-		if (hasOffers && hasCalldata) ctx.addIssue({
-			code: "custom",
-			message: "Request body must contain either 'offers' or 'calldata', not both"
-		});
-		if (!hasOffers && !hasCalldata) ctx.addIssue({
-			code: "custom",
-			message: "Request body must contain either 'offers' array or 'calldata' hex string"
-		});
-	})
+	validate_offers: zod.object({ offers: zod.array(zod.unknown()).min(1, { message: "'offers' must contain at least 1 offer" }) }).strict()
 };
 function parse(action, query) {
 	return schemas[action].parse(query);
@@ -1225,8 +1259,12 @@ function decode$2(type, data) {
 }
 function encode$2(type, data) {
 	switch (type) {
-		case CallbackType.BuyVaultV1Callback: return encodeBuyVaultV1Callback(data);
-		case CallbackType.SellERC20Callback: return encodeSellERC20Callback(data);
+		case CallbackType.BuyVaultV1Callback:
+			if (!("vaults" in data)) throw new Error("Invalid callback data");
+			return encodeBuyVaultV1Callback(data);
+		case CallbackType.SellERC20Callback:
+			if (!("collaterals" in data)) throw new Error("Invalid callback data");
+			return encodeSellERC20Callback(data);
 		default: throw new Error("Invalid callback type");
 	}
 }
@@ -1554,22 +1592,22 @@ const DEFAULT_BATCH_SIZE$1 = 2500;
 const MAX_BLOCK_WINDOW = 1e4;
 const DEFAULT_BLOCK_WINDOW = 8e3;
 async function* streamLogs(parameters) {
-	const { client, contractAddress, event, blockNumberGte, blockNumberLte, order: order$1 = "desc", options: { maxBatchSize = DEFAULT_BATCH_SIZE$1, blockWindow = DEFAULT_BLOCK_WINDOW } = {} } = parameters;
+	const { client, contractAddress, event, blockNumberGte, blockNumberLte, order = "desc", options: { maxBatchSize = DEFAULT_BATCH_SIZE$1, blockWindow = DEFAULT_BLOCK_WINDOW } = {} } = parameters;
 	if (maxBatchSize > MAX_BATCH_SIZE) throw new InvalidBatchSizeError(maxBatchSize);
 	if (blockWindow > MAX_BLOCK_WINDOW) throw new InvalidBlockWindowError(blockWindow);
-	if (order$1 === "asc" && blockNumberGte === void 0) throw new MissingBlockNumberError();
+	if (order === "asc" && blockNumberGte === void 0) throw new MissingBlockNumberError();
 	const latestBlock = (await (0, viem_actions.getBlock)(client, {
 		blockTag: "latest",
 		includeTransactions: false
 	})).number;
 	let toBlock = 0n;
-	if (order$1 === "asc") toBlock = min(BigInt(blockNumberGte) + BigInt(blockWindow), blockNumberLte ? BigInt(blockNumberLte) : latestBlock);
-	if (order$1 === "desc") toBlock = blockNumberLte === void 0 ? latestBlock : min(BigInt(blockNumberLte), latestBlock);
+	if (order === "asc") toBlock = min(BigInt(blockNumberGte) + BigInt(blockWindow), blockNumberLte ? BigInt(blockNumberLte) : latestBlock);
+	if (order === "desc") toBlock = blockNumberLte === void 0 ? latestBlock : min(BigInt(blockNumberLte), latestBlock);
 	let fromBlock = 0n;
-	if (order$1 === "asc") fromBlock = min(BigInt(blockNumberGte), latestBlock);
-	if (order$1 === "desc") fromBlock = max$1(BigInt(blockNumberGte || toBlock - BigInt(blockWindow)), 0n);
-	if (order$1 === "asc") toBlock = min(toBlock, fromBlock + BigInt(blockWindow));
-	if (order$1 === "desc") fromBlock = max$1(fromBlock, toBlock - BigInt(blockWindow));
+	if (order === "asc") fromBlock = min(BigInt(blockNumberGte), latestBlock);
+	if (order === "desc") fromBlock = max$1(BigInt(blockNumberGte || toBlock - BigInt(blockWindow)), 0n);
+	if (order === "asc") toBlock = min(toBlock, fromBlock + BigInt(blockWindow));
+	if (order === "desc") fromBlock = max$1(fromBlock, toBlock - BigInt(blockWindow));
 	if (fromBlock > toBlock) throw new InvalidBlockRangeError(fromBlock, toBlock);
 	let streaming = true;
 	while (streaming) {
@@ -1579,29 +1617,29 @@ async function* streamLogs(parameters) {
 			fromBlock,
 			toBlock
 		});
-		streaming = order$1 === "asc" ? toBlock < (blockNumberLte || latestBlock) : fromBlock > (blockNumberGte || 0n);
+		streaming = order === "asc" ? toBlock < (blockNumberLte || latestBlock) : fromBlock > (blockNumberGte || 0n);
 		if (logs.length === 0 && !streaming) break;
 		if (logs.length === 0 && streaming) yield {
 			logs: [],
-			blockNumber: order$1 === "asc" ? Number(toBlock) : Number(fromBlock)
+			blockNumber: order === "asc" ? Number(toBlock) : Number(fromBlock)
 		};
 		logs.sort((a, b) => {
-			if (a.blockNumber !== b.blockNumber) return order$1 === "asc" ? Number(a.blockNumber - b.blockNumber) : Number(b.blockNumber - a.blockNumber);
-			if (a.transactionIndex !== b.transactionIndex) return order$1 === "asc" ? a.transactionIndex - b.transactionIndex : b.transactionIndex - a.transactionIndex;
-			return order$1 === "asc" ? a.logIndex - b.logIndex : b.logIndex - a.logIndex;
+			if (a.blockNumber !== b.blockNumber) return order === "asc" ? Number(a.blockNumber - b.blockNumber) : Number(b.blockNumber - a.blockNumber);
+			if (a.transactionIndex !== b.transactionIndex) return order === "asc" ? a.transactionIndex - b.transactionIndex : b.transactionIndex - a.transactionIndex;
+			return order === "asc" ? a.logIndex - b.logIndex : b.logIndex - a.logIndex;
 		});
 		for (const logBatch of batch(logs, maxBatchSize)) yield {
 			logs: logBatch,
-			blockNumber: logBatch.length === maxBatchSize ? Number(logBatch[logBatch.length - 1]?.blockNumber) : order$1 === "asc" ? Number(toBlock) : Number(fromBlock)
+			blockNumber: logBatch.length === maxBatchSize ? Number(logBatch[logBatch.length - 1]?.blockNumber) : order === "asc" ? Number(toBlock) : Number(fromBlock)
 		};
-		if (order$1 === "asc") {
+		if (order === "asc") {
 			const upperBound = BigInt(blockNumberLte || latestBlock);
 			const nextFromBlock = min(BigInt(toBlock) + 1n, upperBound);
 			const nextToBlock = min(toBlock + BigInt(blockWindow) + 1n, upperBound);
 			fromBlock = nextFromBlock;
 			toBlock = nextToBlock;
 		}
-		if (order$1 === "desc") {
+		if (order === "desc") {
 			const lowerBound = BigInt(blockNumberGte || 0);
 			const nextToBlock = max$1(fromBlock - 1n, lowerBound);
 			const nextFromBlock = max$1(fromBlock - BigInt(blockWindow) - 1n, lowerBound);
@@ -1611,7 +1649,7 @@ async function* streamLogs(parameters) {
 	}
 	yield {
 		logs: [],
-		blockNumber: order$1 === "asc" ? Number(toBlock) : Number(fromBlock)
+		blockNumber: order === "asc" ? Number(toBlock) : Number(fromBlock)
 	};
 }
 var InvalidBlockRangeError = class extends BaseError {
@@ -1639,6 +1677,96 @@ var MissingBlockNumberError = class extends BaseError {
 	}
 };
 
+//#endregion
+//#region src/utils/Random.ts
+var Random_exports = /* @__PURE__ */ __export({
+	address: () => address,
+	bool: () => bool,
+	bytes: () => bytes,
+	float: () => float,
+	hex: () => hex,
+	int: () => int,
+	seed: () => seed,
+	withSeed: () => withSeed
+});
+let currentRng = Math.random;
+const FNV_OFFSET_BASIS = 2166136261;
+const FNV_PRIME = 16777619;
+const hashSeed = (seed$1) => {
+	let hash$1 = FNV_OFFSET_BASIS;
+	for (let i = 0; i < seed$1.length; i += 1) {
+		hash$1 ^= seed$1.charCodeAt(i);
+		hash$1 = Math.imul(hash$1, FNV_PRIME);
+	}
+	return hash$1 >>> 0;
+};
+const createSeededRng = (seed$1) => {
+	let state = hashSeed(seed$1);
+	return () => {
+		state += 1831565813;
+		let t = Math.imul(state ^ state >>> 15, state | 1);
+		t ^= t + Math.imul(t ^ t >>> 7, t | 61);
+		return ((t ^ t >>> 14) >>> 0) / 4294967296;
+	};
+};
+/**
+* Runs a function with a deterministic RNG derived from the given seed.
+*/
+function withSeed(seed$1, fn) {
+	const previous = currentRng;
+	currentRng = createSeededRng(seed$1);
+	try {
+		return fn();
+	} finally {
+		currentRng = previous;
+	}
+}
+/**
+* Seeds the global RNG for deterministic test runs.
+*/
+function seed(seed$1) {
+	currentRng = createSeededRng(seed$1);
+}
+/**
+* Returns a deterministic random float in [0, 1).
+*/
+function float() {
+	return currentRng();
+}
+/**
+* Returns a deterministic random integer in [min, maxExclusive).
+*/
+function int(maxExclusive, min$1 = 0) {
+	return Math.floor(float() * (maxExclusive - min$1)) + min$1;
+}
+/**
+* Returns a deterministic random boolean.
+*/
+function bool(probability = .5) {
+	return float() < probability;
+}
+/**
+* Returns deterministic random bytes.
+*/
+function bytes(length) {
+	const output = new Uint8Array(length);
+	for (let i = 0; i < length; i += 1) output[i] = int(256);
+	return output;
+}
+/**
+* Returns a deterministic random hex string for the given byte length.
+*/
+function hex(byteLength) {
+	const output = bytes(byteLength);
+	return `0x${Array.from(output, (byte) => byte.toString(16).padStart(2, "0")).join("")}`;
+}
+/**
+* Returns a deterministic random address.
+*/
+function address() {
+	return hex(20);
+}
+
 //#endregion
 //#region src/utils/zod.ts
 const transformHex = (val, ctx) => {
@@ -1760,8 +1888,8 @@ const from$9 = (parameters) => {
 */
 function random$3() {
 	return from$9({
-		asset: (0, viem_accounts.privateKeyToAccount)((0, viem_accounts.generatePrivateKey)()).address,
-		oracle: (0, viem_accounts.privateKeyToAccount)((0, viem_accounts.generatePrivateKey)()).address,
+		asset: address(),
+		oracle: address(),
 		lltv: .965
 	});
 }
@@ -2176,12 +2304,8 @@ function id(obligation) {
 function random$2() {
 	return from$7({
 		chainId: 1,
-		loanToken: (0, viem_accounts.privateKeyToAccount)((0, viem_accounts.generatePrivateKey)()).address,
-		collaterals: [from$9({
-			asset: (0, viem_accounts.privateKeyToAccount)((0, viem_accounts.generatePrivateKey)()).address,
-			oracle: (0, viem_accounts.privateKeyToAccount)((0, viem_accounts.generatePrivateKey)()).address,
-			lltv: .965
-		})],
+		loanToken: address(),
+		collaterals: [random$3()],
 		maturity: from$8("end_of_next_quarter")
 	});
 }
@@ -2201,101 +2325,249 @@ var CollateralsAreNotSortedError = class extends BaseError {
 //#endregion
 //#region src/core/Tree.ts
 var Tree_exports = /* @__PURE__ */ __export({
+	DecodeError: () => DecodeError,
+	EncodeError: () => EncodeError,
+	TreeError: () => TreeError,
 	VERSION: () => VERSION,
 	decode: () => decode$1,
 	encode: () => encode$1,
-	from: () => from$6
+	encodeUnsigned: () => encodeUnsigned,
+	from: () => from$6,
+	proofs: () => proofs
 });
 const VERSION = 1;
+const normalizeHash = (hash$1) => hash$1.toLowerCase();
 /**
 * Builds a Merkle tree from a list of offers.
 *
 * Leaves are the offer `hash` values as `bytes32` and are deterministically
-* ordered in ascending lexicographic order so that the resulting root is stable
-* regardless of the input order.
+* ordered following the StandardMerkleTree leaf ordering so that the resulting
+* root is stable regardless of the input order.
 *
 * @param offers - Offers to include in the tree.
 * @returns A `StandardMerkleTree` of `bytes32` leaves representing the offers.
+* @throws {TreeError} If tree building fails due to offer inconsistencies.
 */
 const from$6 = (offers) => {
-	const leaves = order(offers).map((offer) => {
-		return [offer.hash];
-	});
+	const leaves = offers.map((offer) => [offer.hash]);
 	const tree = __openzeppelin_merkle_tree.StandardMerkleTree.of(leaves, ["bytes32"]);
-	return Object.assign(tree, { offers });
+	const orderedOffers = orderOffers(tree, offers);
+	return Object.assign(tree, { offers: orderedOffers });
 };
-const byHashAsc = (a, b) => a.localeCompare(b);
-const order = (offers) => {
-	return offers.sort((a, b) => byHashAsc(a.hash, b.hash));
+const orderOffers = (tree, offers) => {
+	const offerByHash = /* @__PURE__ */ new Map();
+	for (const offer of offers) offerByHash.set(normalizeHash(offer.hash), offer);
+	const entries = tree.dump().values.map((value) => {
+		const hash$1 = normalizeHash(value.value[0]);
+		const offer = offerByHash.get(hash$1);
+		if (!offer) throw new TreeError(`missing offer for leaf ${hash$1}`);
+		return {
+			offer,
+			treeIndex: value.treeIndex
+		};
+	});
+	entries.sort((a, b) => b.treeIndex - a.treeIndex);
+	return entries.map((item) => item.offer);
 };
 /**
-* Encodes an `Tree` into a Hex string with a version byte prefix and gzipped payload.
+* Generates merkle proofs for all offers in a tree.
 *
-* - Layout: `0x{vv}{zip...}` where `{vv}` is one-byte version as two hex chars.
-* - Payload is gzip(JSON.stringify([root, ...offers])) with bigint stringified.
+* Each proof allows independent verification that an offer is included in the tree
+* without requiring the full tree. Proofs are ordered by StandardMerkleTree leaf ordering.
 *
-* @param tree - The offer Merkle tree to encode.
-* @returns Hex string starting with `0x{vv}` followed by gzipped payload bytes.
-* @throws Error if the given `root` does not match the offers.
-*/
-const encode$1 = (tree) => {
-	assertRoot(tree.root, tree.offers);
-	const offersPayload = tree.offers.map((offer) => ({
-		offering: offer.offering,
-		assets: offer.assets.toString(),
-		rate: offer.rate.toString(),
-		maturity: Number(offer.maturity),
-		expiry: Number(offer.expiry),
-		start: Number(offer.start),
-		nonce: offer.nonce.toString(),
-		buy: offer.buy,
-		chainId: offer.chainId,
-		loanToken: offer.loanToken,
-		collaterals: offer.collaterals.map((c) => ({
-			asset: c.asset,
-			oracle: c.oracle,
-			lltv: c.lltv.toString()
-		})),
-		callback: {
-			address: offer.callback.address,
-			data: offer.callback.data,
-			gasLimit: offer.callback.gasLimit.toString()
-		},
-		signature: offer.signature,
-		hash: offer.hash
-	}));
-	const compressed = (0, pako.gzip)(JSON.stringify([tree.root, ...offersPayload]));
-	const encoded = new Uint8Array(1 + compressed.length);
-	if (VERSION > 255) throw new Error(`Version overflow: ${VERSION}`);
-	encoded[0] = VERSION;
-	encoded.set(compressed, 1);
+* @param tree - The {@link Tree} to generate proofs for.
+* @returns Array of proofs - {@link Proof}
+*/
+const proofs = (tree) => {
+	return tree.offers.map((offer) => {
+		return {
+			offer,
+			path: tree.getProof([offer.hash])
+		};
+	});
+};
+const assertHex = (value, expectedBytes, name) => {
+	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$1 = (0, viem.hashMessage)({ raw: root });
+	try {
+		return await (0, viem.recoverAddress)({
+			hash: hash$1,
+			signature
+		});
+	} catch {
+		throw new DecodeError("signature recovery failed");
+	}
+};
+/**
+* Encodes a merkle tree with signature into hex calldata for onchain broadcast.
+*
+* Layout: `0x{vv}{gzip([...offers])}{root}{signature}` where:
+* - `{vv}`: 1-byte version (currently 0x01)
+* - `{gzip([...offers])}`: gzipped JSON array of serialized offers
+* - `{root}`: 32-byte merkle root
+* - `{signature}`: 65-byte EIP-191 signature over raw root bytes
+*
+* Validates signature authenticity and root integrity before encoding.
+*
+* @example
+* ```typescript
+* const tree = Tree.from(offers);
+* const signature = await wallet.signMessage({ message: { raw: tree.root } });
+* const calldata = await Tree.encode(tree, signature);
+* await broadcast(calldata);
+* ```
+*
+* @example
+* Manual construction (for advanced users):
+* ```typescript
+* const tree = Tree.from(offers);
+* const compressed = gzip(JSON.stringify(tree.offers.map(Offer.serialize)));
+* const partial = `0x01${bytesToHex(compressed)}${tree.root.slice(2)}`;
+* const signature = await wallet.signMessage({ message: { raw: tree.root } });
+* const calldata = `${partial}${signature.slice(2)}`;
+* ```
+*
+* @param tree - Merkle tree of offers
+* @param signature - EIP-191 signature over raw root bytes
+* @returns Hex-encoded calldata ready for onchain broadcast
+* @throws {EncodeError} If signature verification fails or root mismatch
+*/
+const encode$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);
 };
-const assertRoot = (root, offers) => {
-	const tree = from$6(offers);
-	if (root !== tree.root) throw new Error(`Invalid root: expected ${tree.root}, got ${root}`);
+/**
+* Encodes a merkle tree without a signature into hex payload for client-side signing.
+*
+* Layout: `0x{vv}{gzip([...offers])}{root}` where:
+* - `{vv}`: 1-byte version (currently 0x01)
+* - `{gzip([...offers])}`: gzipped JSON array of serialized offers
+* - `{root}`: 32-byte merkle root
+*
+* Validates root integrity before encoding.
+*
+* @param tree - Merkle tree of offers
+* @returns Hex-encoded unsigned payload
+* @throws {EncodeError} If root mismatch
+*/
+const encodeUnsigned = (tree) => {
+	validateTreeForEncoding(tree);
+	return (0, viem.bytesToHex)(encodeUnsignedBytes(tree));
+};
+const validateTreeForEncoding = (tree) => {
+	if (VERSION > 255) throw new EncodeError(`version overflow: ${VERSION} exceeds 255`);
+	const computed = from$6(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 a Hex string produced by {@link encode} back into an `Tree`.
+* Decodes hex calldata into a validated merkle tree.
+*
+* Validates signature before decompression for fail-fast rejection of invalid payloads.
+* Returns the tree with separately validated signature and recovered signer address.
+*
+* 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)
 *
-* - Ensures the first byte version matches {@link VERSION}.
-* - Decompresses with gunzip, parses JSON, validates offers, and re-checks the 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 string in the form `0x{vv}{zip...}`.
-* @returns A validated `Tree` rebuilt from the offers.
-* @throws Error if the version is invalid or the root does not match the offers.
-*/
-const decode$1 = (encoded) => {
-	const bytes = (0, viem.hexToBytes)(encoded);
-	if (bytes.length < 2) throw new Error("Invalid payload: too short");
-	const version = bytes[0];
-	if (version !== (VERSION & 255)) throw new Error(`Invalid version: expected ${VERSION}, got ${version}`);
-	const decoded = (0, pako.ungzip)(bytes.slice(1), { to: "string" });
-	const data = JSON.parse(decoded);
-	const root = data[0];
-	const tree = from$6(data.slice(1).map((o) => OfferSchema().parse(o)));
-	if (root !== tree.root) throw new Error(`Invalid root: expected ${tree.root}, got ${root}`);
-	return tree;
+* @param encoded - Hex calldata in format `0x{vv}{gzip}{root}{signature}`
+* @returns Validated tree, signature, and recovered signer address
+* @throws {DecodeError} If version invalid, signature invalid, or root mismatch
+*/
+const decode$1 = async (encoded) => {
+	const bytes$1 = (0, viem.hexToBytes)(encoded);
+	if (bytes$1.length < 98) throw new DecodeError("payload too short");
+	const version = bytes$1[0];
+	if (version !== (VERSION & 255)) throw new DecodeError(`invalid version: expected ${VERSION}, got ${version ?? 0}`);
+	const signature = (0, viem.bytesToHex)(bytes$1.slice(-65));
+	const root = (0, viem.bytesToHex)(bytes$1.slice(-97, -65));
+	assertHex(root, 32, "root");
+	assertHex(signature, 65, "signature");
+	const signer = await verifySignatureAndRecoverAddress({
+		root,
+		signature
+	});
+	const compressed = bytes$1.slice(1, -97);
+	let decoded;
+	try {
+		decoded = (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$6(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
@@ -2315,6 +2587,7 @@ var Offer_exports = /* @__PURE__ */ __export({
 	hash: () => hash,
 	obligationId: () => obligationId,
 	random: () => random$1,
+	serialize: () => serialize,
 	sign: () => sign,
 	signatureMsg: () => signatureMsg,
 	toSnakeCase: () => toSnakeCase,
@@ -2395,16 +2668,47 @@ function toSnakeCase(offer) {
 	return toSnakeCase$1(offer);
 }
 /**
+* Serializes an offer for merkle tree encoding.
+* Converts BigInt fields to strings for JSON compatibility.
+*
+* @param offer - Offer to serialize
+* @returns JSON-serializable offer object
+*/
+const serialize = (offer) => ({
+	offering: offer.offering,
+	assets: offer.assets.toString(),
+	rate: offer.rate.toString(),
+	maturity: Number(offer.maturity),
+	expiry: Number(offer.expiry),
+	start: Number(offer.start),
+	nonce: offer.nonce.toString(),
+	buy: offer.buy,
+	chainId: offer.chainId,
+	loanToken: offer.loanToken,
+	collaterals: offer.collaterals.map((c) => ({
+		asset: c.asset,
+		oracle: c.oracle,
+		lltv: c.lltv.toString()
+	})),
+	callback: {
+		address: offer.callback.address,
+		data: offer.callback.data,
+		gasLimit: offer.callback.gasLimit.toString()
+	},
+	signature: offer.signature,
+	hash: offer.hash
+});
+/**
 * Generates a random Offer.
 * The returned Offer contains randomly generated values.
 * @warning The generated Offer should not be used for production usage.
 * @returns {Offer} A randomly generated Offer object.
 */
 function random$1(config) {
-	const chain = config?.chains ? config.chains[Math.floor(Math.random() * config.chains.length)] : chains$1.ethereum;
-	const loanToken = config?.loanTokens ? config.loanTokens[Math.floor(Math.random() * config.loanTokens.length)] : (0, viem_accounts.privateKeyToAccount)((0, viem_accounts.generatePrivateKey)()).address;
-	const collateralCandidates = config?.collateralTokens ? config.collateralTokens.filter((a) => a !== loanToken) : [(0, viem_accounts.privateKeyToAccount)((0, viem_accounts.generatePrivateKey)()).address];
-	const collateralAsset = collateralCandidates[Math.floor(Math.random() * collateralCandidates.length)];
+	const chain = config?.chains ? config.chains[int(config.chains.length)] : chains$1.ethereum;
+	const loanToken = config?.loanTokens ? config.loanTokens[int(config.loanTokens.length)] : address();
+	const collateralCandidates = config?.collateralTokens ? config.collateralTokens.filter((a) => a !== loanToken) : [address()];
+	const collateralAsset = collateralCandidates[int(collateralCandidates.length)];
 	const maturityOption = weightedChoice([["end_of_month", 1], ["end_of_next_month", 1]]);
 	const maturity$1 = config?.maturity ?? from$8(maturityOption);
 	const lltv = from$10(weightedChoice([
@@ -2418,7 +2722,7 @@ function random$1(config) {
 		[.965, 4],
 		[.98, 2]
 	]));
-	const buy = config?.buy !== void 0 ? config.buy : Math.random() > .5;
+	const buy = config?.buy !== void 0 ? config.buy : bool();
 	const ONE = 1000000000000000000n;
 	const qMin = buy ? 16 : 4;
 	const len = (buy ? 32 : 16) - qMin + 1;
@@ -2429,9 +2733,9 @@ function random$1(config) {
 	const rate = config?.rate ?? weightedChoice(ratePairs);
 	const loanTokenDecimals = config?.assetsDecimals?.[loanToken] ?? 18;
 	const unit = BigInt(10) ** BigInt(loanTokenDecimals);
-	const amountBase = BigInt(100 + Math.floor(Math.random() * 999901));
+	const amountBase = BigInt(100 + int(999901));
 	const assetsScaled = config?.assets ?? amountBase * unit;
-	const consumed = config?.consumed !== void 0 ? config.consumed : Math.random() < .8 ? 0n : assetsScaled * BigInt(1 + Math.floor(Math.random() * 900)) / 1000n;
+	const consumed = config?.consumed !== void 0 ? config.consumed : float() < .8 ? 0n : assetsScaled * BigInt(1 + int(900)) / 1000n;
 	const callbackBySide = (() => {
 		if (buy) return {
 			address: viem.zeroAddress,
@@ -2450,29 +2754,29 @@ function random$1(config) {
 		};
 	})();
 	return from$5({
-		offering: config?.offering ?? (0, viem_accounts.privateKeyToAccount)((0, viem_accounts.generatePrivateKey)()).address,
+		offering: config?.offering ?? address(),
 		assets: assetsScaled,
 		rate,
 		maturity: maturity$1,
 		expiry: config?.expiry ?? maturity$1 - 1,
 		start: config?.start ?? maturity$1 - 10,
-		nonce: BigInt(Math.floor(Math.random() * 1e6)),
+		nonce: BigInt(int(1e6)),
 		buy,
 		chainId: chain.id,
 		loanToken,
-		collaterals: config?.collaterals ?? Array.from({ length: Math.floor(Math.random() * 3) + 1 }, () => ({
+		collaterals: config?.collaterals ?? Array.from({ length: int(3) + 1 }, () => ({
 			...random$3(),
 			lltv
 		})).sort((a, b) => a.asset.localeCompare(b.asset)),
 		callback: config?.callback ?? callbackBySide,
 		consumed,
 		takeable: config?.takeable ?? assetsScaled - consumed,
-		blockNumber: config?.blockNumber ?? Math.floor(Math.random() * Number.MAX_SAFE_INTEGER)
+		blockNumber: config?.blockNumber ?? int(Number.MAX_SAFE_INTEGER)
 	});
 }
 const weightedChoice = (pairs) => {
 	const total = pairs.reduce((sum, [, weight]) => sum + weight, 0);
-	let roll = Math.random() * total;
+	let roll = float() * total;
 	for (const [value, weight] of pairs) {
 		roll -= weight;
 		if (roll < 0) return value;
@@ -2940,8 +3244,8 @@ function fromSnakeCase(snake) {
 function random() {
 	return from$2({
 		obligationId: id(random$2()),
-		ask: { rate: BigInt(Math.floor(Math.random() * 1e6)) },
-		bid: { rate: BigInt(Math.floor(Math.random() * 1e6)) }
+		ask: { rate: BigInt(int(1e6)) },
+		bid: { rate: BigInt(int(1e6)) }
 	});
 }
 var InvalidQuoteError = class extends BaseError {
@@ -3041,24 +3345,28 @@ async function getOffers(apiClient, parameters) {
 		throw new HttpGetApiFailedError(`GET request returned ${response.status}`, { details: JSON.stringify(error) });
 	}
 	const offers = data?.data.map((item) => {
-		const { signature, ...rest } = item;
-		return fromSnakeCase$1({
-			...rest,
-			offering: item.offering,
-			maturity: from$8(item.maturity),
-			loan_token: item.loan_token,
-			collaterals: item.collaterals.map((collateral) => ({
-				asset: collateral.asset,
-				oracle: collateral.oracle,
-				lltv: collateral.lltv
-			})),
-			callback: {
-				...item.callback,
-				address: item.callback.address,
-				data: item.callback.data
-			},
-			...signature !== null ? { signature: item.signature } : void 0
-		});
+		const { root, proof, signature, ...rest } = item;
+		return {
+			...fromSnakeCase$1({
+				...rest,
+				offering: item.offering,
+				maturity: from$8(item.maturity),
+				loan_token: item.loan_token,
+				collaterals: item.collaterals.map((collateral) => ({
+					asset: collateral.asset,
+					oracle: collateral.oracle,
+					lltv: collateral.lltv
+				})),
+				callback: {
+					...item.callback,
+					address: item.callback.address,
+					data: item.callback.data
+				},
+				signature: signature?.toLowerCase()
+			}),
+			root: root?.toLowerCase() || void 0,
+			proof: proof?.map((p) => p.toLowerCase()) || void 0
+		};
 	}) ?? [];
 	return {
 		cursor: data?.cursor ?? null,
@@ -3249,8 +3557,8 @@ function getCallback(chain, type) {
 * @param address - Callback contract address
 * @returns The callback type when found, otherwise undefined
 */
-function getCallbackType(chain, address) {
-	return configs[chain].callbacks?.find((c) => c.type !== CallbackType.BuyWithEmptyCallback && c.addresses.includes(address?.toLowerCase()))?.type;
+function getCallbackType(chain, address$1) {
+	return configs[chain].callbacks?.find((c) => c.type !== CallbackType.BuyWithEmptyCallback && c.addresses.includes(address$1?.toLowerCase()))?.type;
 }
 /**
 * Returns the callback addresses for a given chain and callback type, if it exists.
@@ -3383,6 +3691,7 @@ var Rules_exports = /* @__PURE__ */ __export({
 	callback: () => callback,
 	chains: () => chains,
 	maturity: () => maturity,
+	sameMaker: () => sameMaker,
 	token: () => token,
 	validity: () => validity
 });
@@ -3519,10 +3828,29 @@ const token = ({ assets: assets$1 }) => single("token", "Validates that offer lo
 	if (!allowedAssets.includes(offer.loanToken.toLowerCase())) return { message: "Loan token is not allowed" };
 	if (offer.collaterals.some((collateral) => !allowedAssets.includes(collateral.asset.toLowerCase()))) return { message: "Collateral is not allowed" };
 });
+/**
+* A batch validation rule that ensures all offers in a tree have the same maker (offering address).
+* Returns an issue only for the first non-conforming offer.
+* This rule is signing-agnostic; signer verification is handled at the collector level.
+*/
+const sameMaker = () => batch$1("mixed_maker", "Validates that all offers in a batch have the same maker (offering address)", (offers) => {
+	const issues = /* @__PURE__ */ new Map();
+	if (offers.length === 0) return issues;
+	const firstMaker = offers[0].offering.toLowerCase();
+	for (let i = 1; i < offers.length; i++) {
+		const offer = offers[i];
+		if (offer.offering.toLowerCase() !== firstMaker) {
+			issues.set(i, { message: `Offer has different maker ${offer.offering} than first offer ${offers[0].offering}` });
+			return issues;
+		}
+	}
+	return issues;
+});
 
 //#endregion
 //#region src/gatekeeper/morphoRules.ts
 const morphoRules = (chains$2) => [
+	sameMaker(),
 	chains({ chains: chains$2 }),
 	maturity({ maturities: [MaturityType.EndOfMonth, MaturityType.EndOfNextMonth] }),
 	callback({
@@ -3563,22 +3891,24 @@ async function add(config, offers) {
 	const tree = from$6(offers.map((o) => from$5(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);
 	try {
 		return await config.client.sendTransaction({
 			chain: config.client.chain,
 			account: config.client.account,
 			to: config.mempoolAddress,
-			data: encode$1(tree)
+			data: encoded
 		});
 	} catch (error) {
 		throw new ViemClientError(error instanceof Error ? error.message : "Unknown error");
 	}
 }
 async function* get(config, parameters) {
-	const { loanToken, blockNumberGte, blockNumberLte, order: order$1 = "desc", options: { maxBatchSize = DEFAULT_BATCH_SIZE } = {} } = parameters || {};
+	const { loanToken, blockNumberGte, blockNumberLte, order = "desc", options: { maxBatchSize = DEFAULT_BATCH_SIZE } = {} } = parameters || {};
 	yield* streamOffers(config, {
 		loanToken,
-		order: order$1,
+		order,
 		blockNumberGte,
 		blockNumberLte,
 		options: {
@@ -3600,7 +3930,7 @@ const getChainId = async (client) => {
 	return chainId;
 };
 async function* streamOffers(config, parameters) {
-	const { loanToken, blockNumberGte, blockNumberLte, order: order$1 = "desc", options: { maxBatchSize = DEFAULT_BATCH_SIZE, blockWindow = config.blockWindow } = {} } = parameters;
+	const { loanToken, blockNumberGte, blockNumberLte, order = "desc", options: { maxBatchSize = DEFAULT_BATCH_SIZE, blockWindow = config.blockWindow } = {} } = parameters;
 	const stream = streamLogs({
 		client: config.client.extend(viem.publicActions),
 		contractAddress: config.mempoolAddress,
@@ -3617,13 +3947,13 @@ async function* streamOffers(config, parameters) {
 		},
 		blockNumberGte,
 		blockNumberLte,
-		order: order$1,
+		order,
 		options: {
 			maxBatchSize,
 			blockWindow
 		}
 	});
-	let blockNumber = order$1 === "asc" ? blockNumberGte : blockNumberLte;
+	let blockNumber = order === "asc" ? blockNumberGte : blockNumberLte;
 	for await (const { logs, blockNumber: newBlockNumber } of stream) {
 		blockNumber = newBlockNumber;
 		if (logs.length === 0) continue;
@@ -3632,7 +3962,7 @@ async function* streamOffers(config, parameters) {
 			if (!log) continue;
 			const [payload] = (0, viem.decodeAbiParameters)([{ type: "bytes" }], log.data);
 			try {
-				const tree = decode$1(payload);
+				const { tree } = await decode$1(payload);
 				for (const offer of tree.offers) {
 					if (loanToken && offer.loanToken.toLowerCase() !== loanToken.toLowerCase()) continue;
 					offers.push({
@@ -3801,6 +4131,7 @@ function max() {
 //#region src/utils/index.ts
 var utils_exports = /* @__PURE__ */ __export({
 	BaseError: () => BaseError,
+	Random: () => Random_exports,
 	ReorgError: () => ReorgError,
 	Time: () => time_exports,
 	batch: () => batch,