@morpho-dev/router 0.1.17 → 0.2.0

package/dist/index.browser.js

@@ -2,12 +2,19 @@
 
 var v4 = require('zod/v4');
 var viem = require('viem');
-var zodOpenapi = require('zod-openapi');
+require('reflect-metadata');
+var openapiMetadata = require('openapi-metadata');
+var decorators = require('openapi-metadata/decorators');
+var z9 = require('zod');
+var jsBase64 = require('js-base64');
+var createOpenApiFetchClient = require('openapi-fetch');
 var actions = require('viem/actions');
 var chains$1 = require('viem/chains');
-var z7 = require('zod');
 var accounts = require('viem/accounts');
-var jsBase64 = require('js-base64');
+var merkleTree = require('@openzeppelin/merkle-tree');
+var pako = require('pako');
+
+function _interopDefault (e) { return e && e.__esModule ? e : { default: e }; }
 
 function _interopNamespace(e) {
   if (e && e.__esModule) return e;
@@ -27,14 +34,24 @@ function _interopNamespace(e) {
   return Object.freeze(n);
 }
 
-var z7__namespace = /*#__PURE__*/_interopNamespace(z7);
+var z9__namespace = /*#__PURE__*/_interopNamespace(z9);
+var createOpenApiFetchClient__default = /*#__PURE__*/_interopDefault(createOpenApiFetchClient);
 
 var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
 var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
 var __export = (target, all) => {
   for (var name in all)
     __defProp(target, name, { get: all[name], enumerable: true });
 };
+var __decorateClass = (decorators, target, key, kind) => {
+  var result = kind > 1 ? void 0 : kind ? __getOwnPropDesc(target, key) : target;
+  for (var i = decorators.length - 1, decorator; i >= 0; i--)
+    if (decorator = decorators[i])
+      result = (kind ? decorator(target, key, result) : decorator(result)) || result;
+  if (kind && result) __defProp(target, key, result);
+  return result;
+};
 var __publicField = (obj, key, value) => __defNormalProp(obj, typeof key !== "symbol" ? key + "" : key, value);
 
 // src/api/Schema/index.ts
@@ -44,8 +61,11 @@ __export(Schema_exports, {
   ChainsHealthResponse: () => ChainsHealthResponse,
   CollectorHealth: () => CollectorHealth,
   CollectorsHealthResponse: () => CollectorsHealthResponse,
+  HealthController: () => HealthController,
   ObligationResponse: () => ObligationResponse_exports,
+  ObligationsController: () => ObligationsController,
   OfferResponse: () => OfferResponse_exports,
+  OffersController: () => OffersController,
   OpenApi: () => OpenApi,
   RouterStatusResponse: () => RouterStatusResponse,
   parse: () => parse,
@@ -80,6 +100,7 @@ __export(ObligationResponse_exports, {
 var Format_exports = {};
 __export(Format_exports, {
   fromSnakeCase: () => fromSnakeCase,
+  stringifyBigint: () => stringifyBigint,
   toSnakeCase: () => toSnakeCase
 });
 function toSnakeCase(obj) {
@@ -139,9 +160,621 @@ __export(OfferResponse_exports, {
   from: () => from2
 });
 function from2(offer) {
-  return toSnakeCase(offer);
+  const result = toSnakeCase(offer);
+  return { ...result, signature: result.signature ?? null };
+}
+var API_ERROR_CODES = [
+  "VALIDATION_ERROR",
+  "NOT_FOUND",
+  "INTERNAL_SERVER_ERROR",
+  "BAD_REQUEST"
+];
+
+// src/api/Schema/openapi.ts
+var timestampExample = "2024-01-01T12:00:00.000Z";
+var offerCursorExample = "eyJvZmZzZXQiOjEwMH0";
+var obligationCursorExample = "0x25690ae1aee324a005be565f3bcdd16dbf8daf7969b26c181c8b8f467dad9abc";
+var offerExample = {
+  hash: "0xac4bd8318ec914f89f8af913f162230575b0ac0696a19256bc12138c5cfe1427",
+  offering: "0x7b093658BE7f90B63D7c359e8f408e503c2D9401",
+  assets: "369216000000000000000000",
+  rate: "2750000000000000000",
+  maturity: 1761922799,
+  expiry: 1761922799,
+  start: 1761922790,
+  nonce: "571380",
+  buy: false,
+  chain_id: "1",
+  loan_token: "0xC9A9C45C0eB717f8b5F193Af6bAa05A1c0Ac5078",
+  collaterals: [
+    {
+      asset: "0x34Cf890dB685FC536E05652FB41f02090c3fb751",
+      oracle: "0x45093658BE7f90B63D7c359e8f408e503c2D9401",
+      lltv: "860000000000000000"
+    }
+  ],
+  callback: {
+    address: "0x1111111111111111111111111111111111111111",
+    data: "0x00000000000000000000000000000000000000000000000000000000000000400000000000000000000000000000000000000000000000000000000000000080000000000000000000000000000000000000000000000000000000000000000100000000000000000000000034cf890db685fc536e05652fb41f02090c3fb751000000000000000000000000000000000000000000000000000000000000000100000000000000000000000000108e644e3ab01184155270aa92a00000000000",
+    gas_limit: "500000"
+  },
+  signature: "0x1234567890123456789012345678901234567890123456789012345678901234123456789012345678901234567890123456789012345678901234567890123400",
+  consumed: "0",
+  block_number: 2942933377146801
+};
+var collectorsHealthExample = {
+  name: "mempool_offers",
+  chain_id: "1",
+  block_number: 21345678,
+  updated_at: timestampExample,
+  lag: 0,
+  status: "live"
+};
+var chainsHealthExample = {
+  chain_id: "1",
+  block_number: 21345678,
+  updated_at: timestampExample
+};
+var routerStatusExample = {
+  status: "live"
+};
+var Meta = class {
+};
+__decorateClass([
+  decorators.ApiProperty({ type: "string", example: timestampExample })
+], Meta.prototype, "timestamp", 2);
+var SuccessResponse = class {
+};
+__decorateClass([
+  decorators.ApiProperty({ type: "string", enum: ["success"] })
+], SuccessResponse.prototype, "status", 2);
+__decorateClass([
+  decorators.ApiProperty({ type: () => Meta })
+], SuccessResponse.prototype, "meta", 2);
+var ErrorResponse = class {
+};
+__decorateClass([
+  decorators.ApiProperty({ type: "string", enum: API_ERROR_CODES, example: "VALIDATION_ERROR" })
+], ErrorResponse.prototype, "code", 2);
+__decorateClass([
+  decorators.ApiProperty({
+    type: "string",
+    example: "Limit must be greater than 0."
+  })
+], ErrorResponse.prototype, "message", 2);
+__decorateClass([
+  decorators.ApiProperty({
+    type: "object",
+    example: [
+      {
+        field: "limit",
+        issue: "Limit must be greater than 0."
+      }
+    ]
+  })
+], ErrorResponse.prototype, "details", 2);
+var BadRequestResponse = class {
+};
+__decorateClass([
+  decorators.ApiProperty({ type: "string", enum: ["error"] })
+], BadRequestResponse.prototype, "status", 2);
+__decorateClass([
+  decorators.ApiProperty({ type: () => ErrorResponse })
+], BadRequestResponse.prototype, "error", 2);
+__decorateClass([
+  decorators.ApiProperty({ type: () => Meta })
+], BadRequestResponse.prototype, "meta", 2);
+var CollateralResponse = class {
+};
+__decorateClass([
+  decorators.ApiProperty({ type: "string", example: "0x34Cf890dB685FC536E05652FB41f02090c3fb751" })
+], CollateralResponse.prototype, "asset", 2);
+__decorateClass([
+  decorators.ApiProperty({ type: "string", example: "0x45093658BE7f90B63D7c359e8f408e503c2D9401" })
+], CollateralResponse.prototype, "oracle", 2);
+__decorateClass([
+  decorators.ApiProperty({ type: "string", example: "860000000000000000" })
+], CollateralResponse.prototype, "lltv", 2);
+var AskResponse = class {
+};
+__decorateClass([
+  decorators.ApiProperty({ type: "string", example: "1000000000000000000" })
+], AskResponse.prototype, "rate", 2);
+var BidResponse = class {
+};
+__decorateClass([
+  decorators.ApiProperty({ type: "string", example: "1000000000000000000" })
+], BidResponse.prototype, "rate", 2);
+var OfferCallbackResponse = class {
+};
+__decorateClass([
+  decorators.ApiProperty({ type: "string", example: offerExample.callback.address })
+], OfferCallbackResponse.prototype, "address", 2);
+__decorateClass([
+  decorators.ApiProperty({ type: "string", example: offerExample.callback.data })
+], OfferCallbackResponse.prototype, "data", 2);
+__decorateClass([
+  decorators.ApiProperty({ type: "string", example: offerExample.callback.gas_limit })
+], OfferCallbackResponse.prototype, "gas_limit", 2);
+var OfferListItemResponse = class {
+};
+__decorateClass([
+  decorators.ApiProperty({ type: "string", example: offerExample.hash })
+], OfferListItemResponse.prototype, "hash", 2);
+__decorateClass([
+  decorators.ApiProperty({ type: "string", example: offerExample.offering })
+], OfferListItemResponse.prototype, "offering", 2);
+__decorateClass([
+  decorators.ApiProperty({ type: "string", example: offerExample.assets })
+], OfferListItemResponse.prototype, "assets", 2);
+__decorateClass([
+  decorators.ApiProperty({ type: "string", example: offerExample.rate })
+], OfferListItemResponse.prototype, "rate", 2);
+__decorateClass([
+  decorators.ApiProperty({ type: "number", example: offerExample.maturity })
+], OfferListItemResponse.prototype, "maturity", 2);
+__decorateClass([
+  decorators.ApiProperty({ type: "number", example: offerExample.expiry })
+], OfferListItemResponse.prototype, "expiry", 2);
+__decorateClass([
+  decorators.ApiProperty({ type: "number", example: offerExample.start })
+], OfferListItemResponse.prototype, "start", 2);
+__decorateClass([
+  decorators.ApiProperty({ type: "string", example: offerExample.nonce })
+], OfferListItemResponse.prototype, "nonce", 2);
+__decorateClass([
+  decorators.ApiProperty({ type: "boolean", example: offerExample.buy })
+], OfferListItemResponse.prototype, "buy", 2);
+__decorateClass([
+  decorators.ApiProperty({ type: "string", example: offerExample.chain_id })
+], OfferListItemResponse.prototype, "chain_id", 2);
+__decorateClass([
+  decorators.ApiProperty({ type: "string", example: offerExample.loan_token })
+], OfferListItemResponse.prototype, "loan_token", 2);
+__decorateClass([
+  decorators.ApiProperty({ type: () => [CollateralResponse], example: offerExample.collaterals })
+], OfferListItemResponse.prototype, "collaterals", 2);
+__decorateClass([
+  decorators.ApiProperty({ type: () => OfferCallbackResponse, example: offerExample.callback })
+], OfferListItemResponse.prototype, "callback", 2);
+__decorateClass([
+  decorators.ApiProperty({ type: "string", example: offerExample.consumed })
+], OfferListItemResponse.prototype, "consumed", 2);
+__decorateClass([
+  decorators.ApiProperty({ type: "number", example: offerExample.block_number })
+], OfferListItemResponse.prototype, "block_number", 2);
+__decorateClass([
+  decorators.ApiProperty({ type: "string", nullable: true, example: offerExample.signature })
+], OfferListItemResponse.prototype, "signature", 2);
+var ObligationResponse = class {
+};
+__decorateClass([
+  decorators.ApiProperty({
+    type: "string",
+    example: "0x12590ae1aee324a005be565f3bcdd16dbf8daf7969b26c181c8b8f467dad9f67"
+  })
+], ObligationResponse.prototype, "id", 2);
+__decorateClass([
+  decorators.ApiProperty({ type: "string", example: "1" })
+], ObligationResponse.prototype, "chain_id", 2);
+__decorateClass([
+  decorators.ApiProperty({ type: "string", example: "0xC9A9C45C0eB717f8b5F193Af6bAa05A1c0Ac5078" })
+], ObligationResponse.prototype, "loan_token", 2);
+__decorateClass([
+  decorators.ApiProperty({ type: () => [CollateralResponse] })
+], ObligationResponse.prototype, "collaterals", 2);
+__decorateClass([
+  decorators.ApiProperty({ type: "number", example: 1761922800 })
+], ObligationResponse.prototype, "maturity", 2);
+__decorateClass([
+  decorators.ApiProperty({ type: () => AskResponse })
+], ObligationResponse.prototype, "ask", 2);
+__decorateClass([
+  decorators.ApiProperty({ type: () => BidResponse })
+], ObligationResponse.prototype, "bid", 2);
+var ObligationListResponse = class extends SuccessResponse {
+};
+__decorateClass([
+  decorators.ApiProperty({ type: "string", nullable: true, example: obligationCursorExample })
+], ObligationListResponse.prototype, "cursor", 2);
+__decorateClass([
+  decorators.ApiProperty({
+    type: () => [ObligationResponse],
+    description: "List of obligations with takable offers."
+  })
+], ObligationListResponse.prototype, "data", 2);
+var ObligationSingleSuccessResponse = class extends SuccessResponse {
+};
+__decorateClass([
+  decorators.ApiProperty({ type: "string", nullable: true, example: null })
+], ObligationSingleSuccessResponse.prototype, "cursor", 2);
+__decorateClass([
+  decorators.ApiProperty({ type: () => ObligationResponse, description: "Obligation details." })
+], ObligationSingleSuccessResponse.prototype, "data", 2);
+var OfferListResponse = class extends SuccessResponse {
+};
+__decorateClass([
+  decorators.ApiProperty({ type: "string", nullable: true, example: offerCursorExample })
+], OfferListResponse.prototype, "cursor", 2);
+__decorateClass([
+  decorators.ApiProperty({
+    type: () => [OfferListItemResponse],
+    description: "Offers matching the provided filters.",
+    example: [offerExample]
+  })
+], OfferListResponse.prototype, "data", 2);
+var RouterStatusDataResponse = class {
+};
+__decorateClass([
+  decorators.ApiProperty({ type: "string", enum: ["live", "syncing"], example: routerStatusExample.status })
+], RouterStatusDataResponse.prototype, "status", 2);
+var RouterStatusSuccessResponse = class extends SuccessResponse {
+};
+__decorateClass([
+  decorators.ApiProperty({
+    type: () => RouterStatusDataResponse,
+    description: "Aggregated router status.",
+    example: routerStatusExample
+  })
+], RouterStatusSuccessResponse.prototype, "data", 2);
+var CollectorHealthResponse = class {
+};
+__decorateClass([
+  decorators.ApiProperty({ type: "string", example: collectorsHealthExample.name })
+], CollectorHealthResponse.prototype, "name", 2);
+__decorateClass([
+  decorators.ApiProperty({ type: "string", example: collectorsHealthExample.chain_id })
+], CollectorHealthResponse.prototype, "chain_id", 2);
+__decorateClass([
+  decorators.ApiProperty({ type: "number", nullable: true, example: collectorsHealthExample.block_number })
+], CollectorHealthResponse.prototype, "block_number", 2);
+__decorateClass([
+  decorators.ApiProperty({ type: "string", nullable: true, example: collectorsHealthExample.updated_at })
+], CollectorHealthResponse.prototype, "updated_at", 2);
+__decorateClass([
+  decorators.ApiProperty({ type: "number", nullable: true, example: collectorsHealthExample.lag })
+], CollectorHealthResponse.prototype, "lag", 2);
+__decorateClass([
+  decorators.ApiProperty({
+    type: "string",
+    enum: ["live", "lagging", "unknown"],
+    example: collectorsHealthExample.status
+  })
+], CollectorHealthResponse.prototype, "status", 2);
+var CollectorsHealthSuccessResponse = class extends SuccessResponse {
+};
+__decorateClass([
+  decorators.ApiProperty({
+    type: () => [CollectorHealthResponse],
+    description: "Collectors health details and sync status.",
+    example: [collectorsHealthExample]
+  })
+], CollectorsHealthSuccessResponse.prototype, "data", 2);
+var ChainHealthResponse = class {
+};
+__decorateClass([
+  decorators.ApiProperty({ type: "string", example: chainsHealthExample.chain_id })
+], ChainHealthResponse.prototype, "chain_id", 2);
+__decorateClass([
+  decorators.ApiProperty({ type: "number", example: chainsHealthExample.block_number })
+], ChainHealthResponse.prototype, "block_number", 2);
+__decorateClass([
+  decorators.ApiProperty({ type: "string", example: chainsHealthExample.updated_at })
+], ChainHealthResponse.prototype, "updated_at", 2);
+var ChainsHealthSuccessResponse = class extends SuccessResponse {
+};
+__decorateClass([
+  decorators.ApiProperty({
+    type: () => [ChainHealthResponse],
+    description: "Latest processed block per chain.",
+    example: [chainsHealthExample]
+  })
+], ChainsHealthSuccessResponse.prototype, "data", 2);
+var OffersController = class {
+  async getOffers() {
+  }
+};
+__decorateClass([
+  decorators.ApiOperation({
+    methods: ["get"],
+    path: "/v1/offers",
+    summary: "List all offers",
+    description: "Returns a list of offers for a given obligation and side. Offers are sorted by the best rate (depending on the side), their block number (older offers first) and their assets (bigger offers first)."
+  }),
+  decorators.ApiQuery({ name: "side", type: "string", required: true, enum: ["buy", "sell"], example: "buy" }),
+  decorators.ApiQuery({
+    name: "obligation_id",
+    type: "string",
+    required: true,
+    example: "0x1234567890123456789012345678901234567890123456789012345678901234",
+    description: "Obligation id used to filter offers."
+  }),
+  decorators.ApiQuery({
+    name: "cursor",
+    type: "string",
+    example: offerCursorExample,
+    description: "Pagination cursor in base64url-encoded format."
+  }),
+  decorators.ApiQuery({
+    name: "limit",
+    type: "number",
+    example: 10,
+    description: "Maximum number of offers to return."
+  }),
+  decorators.ApiResponse({ status: 200, description: "Success", type: OfferListResponse })
+], OffersController.prototype, "getOffers", 1);
+OffersController = __decorateClass([
+  decorators.ApiTags("Offers"),
+  decorators.ApiResponse({ status: 400, description: "Bad Request", type: BadRequestResponse })
+], OffersController);
+var HealthController = class {
+  async getRouterStatus() {
+  }
+  async getCollectorsHealth() {
+  }
+  async getChainsHealth() {
+  }
+};
+__decorateClass([
+  decorators.ApiOperation({
+    methods: ["get"],
+    path: "/v1/health",
+    summary: "Retrieve global health",
+    description: "Returns the aggregated status of the router."
+  }),
+  decorators.ApiResponse({ status: 200, description: "Success", type: RouterStatusSuccessResponse })
+], HealthController.prototype, "getRouterStatus", 1);
+__decorateClass([
+  decorators.ApiOperation({
+    methods: ["get"],
+    path: "/v1/health/collectors",
+    summary: "Retrieve collectors health",
+    description: "Returns the latest block numbers processed by collectors and their sync status."
+  }),
+  decorators.ApiResponse({ status: 200, description: "Success", type: CollectorsHealthSuccessResponse })
+], HealthController.prototype, "getCollectorsHealth", 1);
+__decorateClass([
+  decorators.ApiOperation({
+    methods: ["get"],
+    path: "/v1/health/chains",
+    summary: "Retrieve chains health",
+    description: "Returns the latest block that can be processed by collectors for each chain."
+  }),
+  decorators.ApiResponse({ status: 200, description: "Success", type: ChainsHealthSuccessResponse })
+], HealthController.prototype, "getChainsHealth", 1);
+HealthController = __decorateClass([
+  decorators.ApiTags("Health")
+], HealthController);
+var ObligationsController = class {
+  async getObligations() {
+  }
+  async getObligation() {
+  }
+};
+__decorateClass([
+  decorators.ApiOperation({
+    methods: ["get"],
+    path: "/v1/obligations",
+    summary: "List all obligations",
+    description: "Returns a list of obligations with their current best ask and bid. Obligations are sorted by their id in ascending order by default."
+  }),
+  decorators.ApiQuery({
+    name: "cursor",
+    type: "string",
+    example: obligationCursorExample
+  }),
+  decorators.ApiQuery({ name: "limit", type: "number", example: 10 }),
+  decorators.ApiResponse({ status: 200, description: "Success", type: ObligationListResponse })
+], ObligationsController.prototype, "getObligations", 1);
+__decorateClass([
+  decorators.ApiOperation({
+    methods: ["get"],
+    path: "/v1/obligations/{obligationId}",
+    summary: "Get an obligation",
+    description: "Returns an obligation by its id."
+  }),
+  decorators.ApiResponse({ status: 200, description: "Success", type: ObligationSingleSuccessResponse })
+], ObligationsController.prototype, "getObligation", 1);
+ObligationsController = __decorateClass([
+  decorators.ApiTags("Obligations"),
+  decorators.ApiResponse({ status: 400, description: "Bad Request", type: BadRequestResponse })
+], ObligationsController);
+var OpenApi = async () => await openapiMetadata.generateDocument({
+  controllers: [OffersController, ObligationsController, HealthController],
+  document: {
+    openapi: "3.1.0",
+    info: {
+      title: "Router API",
+      version: "1.0.0",
+      description: "API for the Morpho Router"
+    },
+    servers: [
+      {
+        url: "https://router.morpho.dev",
+        description: "Production server"
+      },
+      {
+        url: "http://localhost:7891",
+        description: "Local development server"
+      }
+    ]
+  }
+});
+
+// src/database/utils/Cursor.ts
+var Cursor_exports = {};
+__export(Cursor_exports, {
+  decode: () => decode,
+  encode: () => encode,
+  validate: () => validate
+});
+function validate(cursor) {
+  if (!cursor || typeof cursor !== "object") {
+    throw new Error("Cursor must be an object");
+  }
+  const c = cursor;
+  if (!["rate", "maturity", "expiry", "amount"].includes(c.sort)) {
+    throw new Error(
+      `Invalid sort field: ${c.sort}. Must be one of: rate, maturity, expiry, amount`
+    );
+  }
+  if (!["asc", "desc"].includes(c.dir)) {
+    throw new Error(`Invalid direction: ${c.dir}. Must be one of: asc, desc`);
+  }
+  if (!/^0x[a-fA-F0-9]{64}$/.test(c.hash)) {
+    throw new Error(
+      `Invalid hash format: ${c.hash}. Must be a 64-character hex string starting with 0x`
+    );
+  }
+  const validations = {
+    rate: {
+      field: "rate",
+      type: "string",
+      pattern: /^\d+$/,
+      error: "numeric string"
+    },
+    amount: {
+      field: "assets",
+      type: "string",
+      pattern: /^\d+$/,
+      error: "numeric string"
+    },
+    maturity: {
+      field: "maturity",
+      type: "number",
+      validator: (val) => val > 0,
+      error: "positive number"
+    },
+    expiry: {
+      field: "expiry",
+      type: "number",
+      validator: (val) => val > 0,
+      error: "positive number"
+    }
+  };
+  const validation = validations[c.sort];
+  if (!validation) {
+    throw new Error(`Invalid sort field: ${c.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");
+    }
+  }
+  return true;
+}
+function encode(c) {
+  return jsBase64.Base64.encodeURL(JSON.stringify(c));
+}
+function decode(token2) {
+  if (!token2) return null;
+  const decoded = JSON.parse(jsBase64.Base64.decode(token2));
+  validate(decoded);
+  return decoded;
+}
+
+// src/api/Schema/requests.ts
+var MAX_LIMIT = 100;
+var DEFAULT_LIMIT = 20;
+var PaginationQueryParams = z9__namespace.object({
+  cursor: z9__namespace.string().optional().refine(
+    (val) => {
+      if (!val) return true;
+      try {
+        const decoded = Cursor_exports.decode(val);
+        return decoded !== null;
+      } catch (_error) {
+        return false;
+      }
+    },
+    {
+      message: "Invalid cursor format. Must be a valid base64url-encoded cursor object"
+    }
+  ).meta({
+    description: "Pagination cursor in base64url-encoded format",
+    example: "eyJzb3J0IjoicHJpY2UiLCJkaXIiOiJkZXNjIiwicHJpY2UiOiIxMDAwMDAwMDAwMDAwMDAwMDAwIiwiaGFzaCI6IjB4ZGRmZDY4NTllM2UwODJkMTkzODlhMWFlYzFiZGFkN2U4ZDkyZDk2YjFhYTc5NDBkYTkxYTMxMjVkMzFlM2JlNWIifQ"
+  }),
+  limit: z9__namespace.string().regex(/^[1-9]\d*$/, {
+    message: "Limit must be a positive integer"
+  }).transform((val) => Number.parseInt(val, 10)).pipe(
+    z9__namespace.number().max(MAX_LIMIT, {
+      message: `Limit cannot exceed ${MAX_LIMIT}`
+    })
+  ).optional().default(DEFAULT_LIMIT).meta({
+    description: `Limit maximum: ${MAX_LIMIT}. Default: ${DEFAULT_LIMIT}`,
+    example: 10
+  })
+});
+var GetOffersQueryParams = z9__namespace.object({
+  ...PaginationQueryParams.shape,
+  side: z9__namespace.enum(["buy", "sell"]).meta({
+    description: "Side of the offer.",
+    example: "buy"
+  }),
+  obligation_id: z9__namespace.string({ error: "Obligation id is required and must be a valid 32-byte hex string" }).regex(/^0x[a-fA-F0-9]{64}$/, { error: "Obligation id must be a valid 32-byte hex string" }).transform((val) => val.toLowerCase()).meta({
+    description: "Offers obligation id",
+    example: "0x1234567890123456789012345678901234567890123456789012345678901234"
+  })
+});
+var GetObligationsQueryParams = z9__namespace.object({
+  ...PaginationQueryParams.shape,
+  cursor: z9__namespace.string().optional().meta({
+    description: "Obligation id cursor",
+    example: "0x1234567890123456789012345678901234567890123456789012345678901234"
+  })
+});
+var GetObligationParams = z9__namespace.object({
+  obligation_id: z9__namespace.string({ error: "Obligation id is required and must be a valid 32-byte hex string" }).regex(/^0x[a-fA-F0-9]{64}$/, { error: "Obligation id must be a valid 32-byte hex string" }).transform((val) => val.toLowerCase()).meta({
+    description: "Obligation id",
+    example: "0x1234567890123456789012345678901234567890123456789012345678901234"
+  })
+});
+var schemas = {
+  get_offers: GetOffersQueryParams,
+  get_obligations: GetObligationsQueryParams,
+  get_obligation: GetObligationParams
+};
+function parse(action, query) {
+  return schemas[action].parse(query);
+}
+function safeParse(action, query, error) {
+  return schemas[action].safeParse(query, {
+    error
+  });
 }
 
+// src/client/Client.ts
+var Client_exports = {};
+__export(Client_exports, {
+  HttpForbiddenError: () => HttpForbiddenError,
+  HttpGetApiFailedError: () => HttpGetApiFailedError,
+  HttpRateLimitError: () => HttpRateLimitError,
+  HttpUnauthorizedError: () => HttpUnauthorizedError,
+  InvalidUrlError: () => InvalidUrlError,
+  connect: () => connect,
+  getObligations: () => getObligations,
+  getOffers: () => getOffers
+});
+
 // src/core/Abi.ts
 var Abi_exports = {};
 __export(Abi_exports, {
@@ -339,11 +972,13 @@ var Morpho = [
 var Callback_exports = {};
 __export(Callback_exports, {
   CallbackType: () => CallbackType,
-  WhitelistedCallbackAddresses: () => WhitelistedCallbackAddresses,
+  decode: () => decode2,
   decodeBuyVaultV1Callback: () => decodeBuyVaultV1Callback,
   decodeSellERC20Callback: () => decodeSellERC20Callback,
+  encode: () => encode2,
   encodeBuyVaultV1Callback: () => encodeBuyVaultV1Callback,
-  encodeSellERC20Callback: () => encodeSellERC20Callback
+  encodeSellERC20Callback: () => encodeSellERC20Callback,
+  isEmptyCallback: () => isEmptyCallback
 });
 var CallbackType = /* @__PURE__ */ ((CallbackType2) => {
   CallbackType2["BuyWithEmptyCallback"] = "buy_with_empty_callback";
@@ -351,19 +986,27 @@ var CallbackType = /* @__PURE__ */ ((CallbackType2) => {
   CallbackType2["SellERC20Callback"] = "sell_erc20_callback";
   return CallbackType2;
 })(CallbackType || {});
-var WhitelistedCallbackAddresses = {
-  ["buy_with_empty_callback" /* BuyWithEmptyCallback */]: [],
-  ["buy_vault_v1_callback" /* BuyVaultV1Callback */]: [
-    "0x3333333333333333333333333333333333333333",
-    "0x4444444444444444444444444444444444444444"
-    // @TODO: update once deployed and add mapping per chain if needed
-  ].map((address) => address.toLowerCase()),
-  ["sell_erc20_callback" /* SellERC20Callback */]: [
-    "0x1111111111111111111111111111111111111111",
-    "0x2222222222222222222222222222222222222222"
-    // @TODO: update once deployed and add mapping per chain if needed
-  ].map((address) => address.toLowerCase())
-};
+var isEmptyCallback = (offer) => offer.callback.data === "0x";
+function decode2(type, data) {
+  switch (type) {
+    case "buy_vault_v1_callback" /* BuyVaultV1Callback */:
+      return decodeBuyVaultV1Callback(data);
+    case "sell_erc20_callback" /* SellERC20Callback */:
+      return decodeSellERC20Callback(data);
+    default:
+      throw new Error("Invalid callback type");
+  }
+}
+function encode2(type, data) {
+  switch (type) {
+    case "buy_vault_v1_callback" /* BuyVaultV1Callback */:
+      return encodeBuyVaultV1Callback(data);
+    case "sell_erc20_callback" /* SellERC20Callback */:
+      return encodeSellERC20Callback(data);
+    default:
+      throw new Error("Invalid callback type");
+  }
+}
 function decodeBuyVaultV1Callback(data) {
   if (!data || data === "0x") throw new Error("Empty callback data");
   try {
@@ -505,62 +1148,30 @@ var chains = {
     ...chains$1.mainnet,
     id: ChainId.ETHEREUM,
     name: "ethereum",
-    whitelistedAssets: new Set(
-      [
-        "0xA0b86991c6218b36c1d19D4a2e9Eb0cE3606eB48",
-        // USDC
-        "0x6B175474E89094C44Da98b954EedeAC495271d0F"
-        // DAI
-      ].map((address) => address.toLowerCase())
-    ),
     morpho: "0x0000000000000000000000000000000000000000",
     morphoBlue: "0xBBBBBbbBBb9cC5e90e3b3Af64bdAF62C37EEFFCb",
     mempool: {
       address: "0x0000000000000000000000000000000000000000",
       deploymentBlock: 23347674,
       reindexBuffer: 10
-    },
-    vaultV1Factory: {
-      "v1.0": "0xA9c3D3a366466Fa809d1Ae982Fb2c46E5fC41101",
-      "v1.1": "0x1897A8997241C1cD4bD0698647e4EB7213535c24"
     }
   },
   base: {
     ...chains$1.base,
     id: ChainId.BASE,
     name: "base",
-    whitelistedAssets: new Set(
-      [
-        "0x833589fCD6eDb6E08f4c7C32D4f71b54bdA02913",
-        // USDC
-        "0x50c5725949A6F0c72E6C4a641F24049A917DB0Cb"
-        // DAI
-      ].map((address) => address.toLowerCase())
-    ),
     morpho: "0x0000000000000000000000000000000000000000",
     morphoBlue: "0xBBBBBbbBBb9cC5e90e3b3Af64bdAF62C37EEFFCb",
     mempool: {
       address: "0x0000000000000000000000000000000000000000",
       deploymentBlock: 35449942,
       reindexBuffer: 10
-    },
-    vaultV1Factory: {
-      "v1.0": "0xA9c3D3a366466Fa809d1Ae982Fb2c46E5fC41101",
-      "v1.1": "0xFf62A7c278C62eD665133147129245053Bbf5918"
     }
   },
   "ethereum-virtual-testnet": {
     ...chains$1.mainnet,
     id: ChainId["ETHEREUM-VIRTUAL-TESTNET"],
     name: "ethereum-virtual-testnet",
-    whitelistedAssets: new Set(
-      [
-        "0xA0b86991c6218b36c1d19D4a2e9Eb0cE3606eB48",
-        // USDC
-        "0x6B175474E89094C44Da98b954EedeAC495271d0F"
-        // DAI
-      ].map((address) => address.toLowerCase())
-    ),
     morpho: "0x11a002d45db720ed47a80d2f3489cba5b833eaf5",
     // @TODO: This is mock Consumed contract, update with Terms once stable
     morphoBlue: "0xBBBBBbbBBb9cC5e90e3b3Af64bdAF62C37EEFFCb",
@@ -568,24 +1179,12 @@ var chains = {
       address: "0x5b06224f736a57635b5bcb50b8ef178b189107cb",
       deploymentBlock: 23224302,
       reindexBuffer: 10
-    },
-    vaultV1Factory: {
-      "v1.0": "0xA9c3D3a366466Fa809d1Ae982Fb2c46E5fC41101",
-      "v1.1": "0x1897A8997241C1cD4bD0698647e4EB7213535c24"
     }
   },
   anvil: {
     ...chains$1.anvil,
     id: ChainId.ANVIL,
     name: "anvil",
-    whitelistedAssets: new Set(
-      [
-        "0xA0b86991c6218b36c1d19D4a2e9Eb0cE3606eB48",
-        // USDC
-        "0x6B175474E89094C44Da98b954EedeAC495271d0F"
-        // DAI
-      ].map((address) => address.toLowerCase())
-    ),
     morpho: "0x23DFBc4B8B80C14CC5e25011B8491f268395BAd6",
     morphoBlue: "0x0000000000000000000000000000000000000000",
     // Set dynamically in tests
@@ -593,10 +1192,6 @@ var chains = {
       address: "0xD946246695A9259F3B33a78629026F61B3Ab40aF",
       deploymentBlock: 23223727,
       reindexBuffer: 10
-    },
-    vaultV1Factory: {
-      "v1.0": "0x0000000000000000000000000000000000000000",
-      "v1.1": "0x0000000000000000000000000000000000000000"
     }
   }
 };
@@ -611,24 +1206,24 @@ async function* streamLogs(parameters) {
     event,
     blockNumberGte,
     blockNumberLte,
-    order = "desc",
+    order: order2 = "desc",
     options: { maxBatchSize = DEFAULT_BATCH_SIZE, 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 === "asc" && blockNumberGte === void 0) throw new MissingBlockNumberError();
+  if (order2 === "asc" && blockNumberGte === void 0) throw new MissingBlockNumberError();
   const latestBlock = (await actions.getBlock(client, { blockTag: "latest", includeTransactions: false })).number;
   let toBlock = 0n;
-  if (order === "asc")
+  if (order2 === "asc")
     toBlock = min(BigInt(blockNumberGte) + BigInt(blockWindow), latestBlock);
-  if (order === "desc")
+  if (order2 === "desc")
     toBlock = blockNumberLte === void 0 ? latestBlock : min(BigInt(blockNumberLte), latestBlock);
   let fromBlock = 0n;
-  if (order === "asc") fromBlock = min(BigInt(blockNumberGte), latestBlock);
-  if (order === "desc")
+  if (order2 === "asc") fromBlock = min(BigInt(blockNumberGte), latestBlock);
+  if (order2 === "desc")
     fromBlock = max(BigInt(blockNumberGte || toBlock - BigInt(blockWindow)), 0n);
-  if (order === "asc") toBlock = min(toBlock, fromBlock + BigInt(blockWindow));
-  if (order === "desc") fromBlock = max(fromBlock, toBlock - BigInt(blockWindow));
+  if (order2 === "asc") toBlock = min(toBlock, fromBlock + BigInt(blockWindow));
+  if (order2 === "desc") fromBlock = max(fromBlock, toBlock - BigInt(blockWindow));
   if (fromBlock > toBlock) throw new InvalidBlockRangeError(fromBlock, toBlock);
   let streaming = true;
   while (streaming) {
@@ -640,10 +1235,10 @@ async function* streamLogs(parameters) {
     });
     logs.sort((a, b) => {
       if (a.blockNumber !== b.blockNumber)
-        return order === "asc" ? Number(a.blockNumber - b.blockNumber) : Number(b.blockNumber - a.blockNumber);
+        return order2 === "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;
+        return order2 === "asc" ? a.transactionIndex - b.transactionIndex : b.transactionIndex - a.transactionIndex;
+      return order2 === "asc" ? a.logIndex - b.logIndex : b.logIndex - a.logIndex;
     });
     for (const logBatch of batch(logs, maxBatchSize)) {
       if (logBatch.length === 0) break;
@@ -654,16 +1249,16 @@ async function* streamLogs(parameters) {
           Number(logBatch[logBatch.length - 1]?.blockNumber)
         ) : (
           // if the batch is not full, return `toBlock` or `fromBlock` to indicate until which block the logs were fetched
-          order === "asc" ? Number(toBlock) : Number(fromBlock)
+          order2 === "asc" ? Number(toBlock) : Number(fromBlock)
         )
       };
     }
-    streaming = order === "asc" ? toBlock < (blockNumberLte || latestBlock) : fromBlock > (blockNumberGte || 0n);
-    if (order === "asc") {
+    streaming = order2 === "asc" ? toBlock < (blockNumberLte || latestBlock) : fromBlock > (blockNumberGte || 0n);
+    if (order2 === "asc") {
       fromBlock = min(BigInt(toBlock) + 1n, latestBlock);
       toBlock = min(fromBlock + BigInt(blockWindow), latestBlock);
     }
-    if (order === "desc") {
+    if (order2 === "desc") {
       const lowerBound = BigInt(blockNumberGte || 0);
       const windowSize = BigInt(blockWindow);
       const nextToBlock = max(fromBlock - 1n, lowerBound);
@@ -672,7 +1267,7 @@ async function* streamLogs(parameters) {
       fromBlock = nextFromBlock;
     }
   }
-  yield { logs: [], blockNumber: order === "asc" ? Number(toBlock) : Number(fromBlock) };
+  yield { logs: [], blockNumber: order2 === "asc" ? Number(toBlock) : Number(fromBlock) };
   return;
 }
 var InvalidBlockRangeError = class extends BaseError {
@@ -711,7 +1306,8 @@ var Collateral_exports = {};
 __export(Collateral_exports, {
   CollateralSchema: () => CollateralSchema,
   CollateralsSchema: () => CollateralsSchema,
-  from: () => from4
+  from: () => from4,
+  random: () => random
 });
 var transformHex = (val, ctx) => {
   if (viem.isHex(val)) return val;
@@ -721,7 +1317,7 @@ var transformHex = (val, ctx) => {
     format: "hex",
     error: "not a hex"
   });
-  return z7__namespace.NEVER;
+  return z9__namespace.NEVER;
 };
 var transformAddress = (val, ctx) => {
   if (viem.isAddress(val.toLowerCase())) return val.toLowerCase();
@@ -731,7 +1327,7 @@ var transformAddress = (val, ctx) => {
     format: "address",
     error: "not a valid address"
   });
-  return z7__namespace.NEVER;
+  return z9__namespace.NEVER;
 };
 
 // src/core/LLTV.ts
@@ -771,7 +1367,7 @@ var InvalidLLTVError = class extends BaseError {
     __publicField(this, "name", "LLTV.InvalidLLTVError");
   }
 };
-var LLTVSchema = z7__namespace.bigint({ coerce: true }).refine(
+var LLTVSchema = z9__namespace.bigint({ coerce: true }).refine(
   (lltv) => {
     try {
       from3(lltv);
@@ -788,12 +1384,12 @@ var LLTVSchema = z7__namespace.bigint({ coerce: true }).refine(
 ).transform((lltv) => from3(lltv));
 
 // src/core/Collateral.ts
-var CollateralSchema = z7__namespace.object({
-  asset: z7__namespace.string().transform(transformAddress),
-  oracle: z7__namespace.string().transform(transformAddress),
+var CollateralSchema = z9__namespace.object({
+  asset: z9__namespace.string().transform(transformAddress),
+  oracle: z9__namespace.string().transform(transformAddress),
   lltv: LLTVSchema
 });
-var CollateralsSchema = z7__namespace.array(CollateralSchema).min(1, { message: "At least one collateral is required" }).refine(
+var CollateralsSchema = z9__namespace.array(CollateralSchema).min(1, { message: "At least one collateral is required" }).refine(
   (collaterals) => {
     for (let i = 1; i < collaterals.length; i++) {
       if (collaterals[i - 1].asset.toLowerCase() > collaterals[i].asset.toLowerCase()) {
@@ -828,6 +1424,13 @@ var from4 = (parameters) => {
     oracle: parameters.oracle.toLowerCase()
   };
 };
+function random() {
+  return from4({
+    asset: accounts.privateKeyToAccount(accounts.generatePrivateKey()).address,
+    oracle: accounts.privateKeyToAccount(accounts.generatePrivateKey()).address,
+    lltv: 0.965
+  });
+}
 
 // src/core/Liquidity.ts
 var Liquidity_exports = {};
@@ -851,20 +1454,20 @@ function calculateMaxDebt(amount, oraclePrice, lltv) {
   return maxDebt;
 }
 function generateBalancePoolId(parameters) {
-  const { user, chainId, token } = parameters;
-  return `${user}-${chainId.toString()}-${token}-balance`.toLowerCase();
+  const { user, chainId, token: token2 } = parameters;
+  return `${user}-${chainId.toString()}-${token2}-balance`.toLowerCase();
 }
 function generateAllowancePoolId(parameters) {
-  const { user, chainId, token } = parameters;
-  return `${user}-${chainId.toString()}-${token}-allowance`.toLowerCase();
+  const { user, chainId, token: token2 } = parameters;
+  return `${user}-${chainId.toString()}-${token2}-allowance`.toLowerCase();
 }
 function generateSellERC20CallbackPoolId(parameters) {
-  const { user, chainId, obligationId: obligationId2, token, offerHash } = parameters;
-  return `${user}-${chainId.toString()}-${obligationId2}-${token}-${offerHash}-sell_erc20_callback`.toLowerCase();
+  const { user, chainId, obligationId: obligationId2, token: token2, offerHash } = parameters;
+  return `${user}-${chainId.toString()}-${obligationId2}-${token2}-${offerHash}-sell_erc20_callback`.toLowerCase();
 }
 function generateObligationCollateralPoolId(parameters) {
-  const { user, chainId, obligationId: obligationId2, token } = parameters;
-  return `${user}-${chainId.toString()}-${obligationId2}-${token}-obligation-collateral`.toLowerCase();
+  const { user, chainId, obligationId: obligationId2, token: token2 } = parameters;
+  return `${user}-${chainId.toString()}-${obligationId2}-${token2}-obligation-collateral`.toLowerCase();
 }
 function generateBuyVaultCallbackPoolId(parameters) {
   const { user, chainId, vault, offerHash } = parameters;
@@ -894,12 +1497,13 @@ __export(Maturity_exports, {
   InvalidFormatError: () => InvalidFormatError,
   InvalidOptionError: () => InvalidOptionError2,
   MaturitySchema: () => MaturitySchema,
+  MaturityType: () => MaturityType,
   from: () => from5
 });
-var MaturitySchema = z7__namespace.number().int().refine(
-  (maturity) => {
+var MaturitySchema = z9__namespace.number().int().refine(
+  (maturity2) => {
     try {
-      from5(maturity);
+      from5(maturity2);
       return true;
     } catch (_e) {
       return false;
@@ -915,7 +1519,16 @@ var MaturitySchema = z7__namespace.number().int().refine(
       }
     }
   }
-).transform((maturity) => maturity);
+).transform((maturity2) => maturity2);
+var MaturityType = /* @__PURE__ */ ((MaturityType2) => {
+  MaturityType2["EndOfWeek"] = "end_of_week";
+  MaturityType2["EndOfNextWeek"] = "end_of_next_week";
+  MaturityType2["EndOfMonth"] = "end_of_month";
+  MaturityType2["EndOfNextMonth"] = "end_of_next_month";
+  MaturityType2["EndOfQuarter"] = "end_of_quarter";
+  MaturityType2["EndOfNextQuarter"] = "end_of_next_quarter";
+  return MaturityType2;
+})(MaturityType || {});
 var MaturityOptions = {
   end_of_week: () => endOfWeek(),
   end_of_next_week: () => endOfNextWeek(),
@@ -936,8 +1549,26 @@ function from5(ts) {
 }
 var endOfWeek = () => fridayOfWeek(0);
 var endOfNextWeek = () => fridayOfWeek(1);
-var endOfMonth = () => lastFridayOfMonth((/* @__PURE__ */ new Date()).getUTCFullYear(), (/* @__PURE__ */ new Date()).getUTCMonth());
-var endOfNextMonth = () => lastFridayOfMonth((/* @__PURE__ */ new Date()).getUTCFullYear(), (/* @__PURE__ */ new Date()).getUTCMonth() + 1);
+var endOfMonth = () => {
+  const now2 = /* @__PURE__ */ new Date();
+  const year = now2.getUTCFullYear();
+  const month = now2.getUTCMonth();
+  const endOfMonth2 = lastFridayOfMonth(year, month);
+  if (now2.getTime() > endOfMonth2 * 1e3) {
+    return lastFridayOfMonth(year, month + 1);
+  }
+  return endOfMonth2;
+};
+var endOfNextMonth = () => {
+  const now2 = /* @__PURE__ */ new Date();
+  const year = now2.getUTCFullYear();
+  const month = now2.getUTCMonth();
+  const endOfMonth2 = lastFridayOfMonth(year, month);
+  if (now2.getTime() > endOfMonth2 * 1e3) {
+    return lastFridayOfMonth(year, month + 2);
+  }
+  return lastFridayOfMonth(year, month + 1);
+};
 var endOfQuarter = () => lastFridayOfQuarter(0);
 var endOfNextQuarter = () => lastFridayOfQuarter(1);
 var fridayOfWeek = (weeksAhead = 0) => {
@@ -958,8 +1589,8 @@ var lastFridayOfMonth = (year, month) => {
   while (lastDayOfMonth15H.getUTCDay() !== 5) {
     lastDayOfMonth15H.setUTCDate(lastDayOfMonth15H.getUTCDate() - 1);
   }
-  const maturity = lastDayOfMonth15H.setUTCDate(lastDayOfMonth15H.getUTCDate()) / 1e3;
-  return maturity;
+  const maturity2 = lastDayOfMonth15H.setUTCDate(lastDayOfMonth15H.getUTCDate()) / 1e3;
+  return maturity2;
 };
 var lastFridayOfQuarter = (quartersAhead = 0) => {
   const now2 = /* @__PURE__ */ new Date();
@@ -1005,11 +1636,11 @@ __export(Obligation_exports, {
   from: () => from6,
   fromSnakeCase: () => fromSnakeCase2,
   id: () => id,
-  random: () => random
+  random: () => random2
 });
-var ObligationSchema = z7__namespace.object({
-  chainId: z7__namespace.bigint({ coerce: true }).min(0n).max(viem.maxUint256),
-  loanToken: z7__namespace.string().transform(transformAddress),
+var ObligationSchema = z9__namespace.object({
+  chainId: z9__namespace.bigint({ coerce: true }).min(0n).max(viem.maxUint256),
+  loanToken: z9__namespace.string().transform(transformAddress),
   collaterals: CollateralsSchema,
   maturity: MaturitySchema
 });
@@ -1067,7 +1698,7 @@ function id(obligation) {
     )
   );
 }
-function random() {
+function random2() {
   return from6({
     chainId: 1n,
     loanToken: accounts.privateKeyToAccount(accounts.generatePrivateKey()).address,
@@ -1101,170 +1732,138 @@ __export(Offer_exports, {
   InvalidOfferError: () => InvalidOfferError,
   OfferHashSchema: () => OfferHashSchema,
   OfferSchema: () => OfferSchema,
+  StatusCode: () => StatusCode,
   consumedEvent: () => consumedEvent,
-  decode: () => decode,
+  decode: () => decode4,
   domain: () => domain,
-  encode: () => encode,
-  from: () => from7,
+  encode: () => encode4,
+  from: () => from8,
   fromConsumedLog: () => fromConsumedLog,
   fromSnakeCase: () => fromSnakeCase3,
   hash: () => hash,
   obligationId: () => obligationId,
-  random: () => random2,
+  random: () => random3,
   sign: () => sign,
+  signatureMsg: () => signatureMsg,
   toSnakeCase: () => toSnakeCase2,
   types: () => types
 });
 
-// src/utils/index.ts
-var utils_exports = {};
-__export(utils_exports, {
-  BaseError: () => BaseError,
-  Time: () => time_exports,
-  batch: () => batch,
-  batchMulticall: () => batchMulticall,
-  fromSnakeCase: () => fromSnakeCase,
-  lazy: () => lazy,
-  max: () => max,
-  min: () => min,
-  poll: () => poll,
-  retry: () => retry,
-  toSnakeCase: () => toSnakeCase,
-  wait: () => wait
+// src/core/Tree.ts
+var Tree_exports = {};
+__export(Tree_exports, {
+  VERSION: () => VERSION,
+  decode: () => decode3,
+  encode: () => encode3,
+  from: () => from7
 });
-
-// src/utils/retry.ts
-var retry = async (fn, attempts = 3, delayMs = 50) => {
-  let lastErr;
-  for (let i = 0; i < attempts; i++) {
-    try {
-      return await fn();
-    } catch (err) {
-      lastErr = err;
-      if (i < attempts - 1) await new Promise((r) => setTimeout(r, delayMs));
-    }
-  }
-  throw lastErr;
+var VERSION = 1;
+var from7 = (offers) => {
+  const leaves = order(offers).map((offer) => {
+    return [offer.hash];
+  });
+  const tree = merkleTree.StandardMerkleTree.of(leaves, ["bytes32"]);
+  return Object.assign(tree, { offers });
 };
-
-// src/utils/batchMulticall.ts
-async function batchMulticall(parameters) {
-  const { client, calls, batchSize, retryAttempts, retryDelayMs, blockNumber } = parameters;
-  const results = [];
-  for (const callsBatch of batch(calls, batchSize)) {
-    const batchResults = await retry(
-      () => client.multicall({
-        allowFailure: false,
-        contracts: callsBatch,
-        ...blockNumber ? { blockNumber } : {}
-      }),
-      retryAttempts,
-      retryDelayMs
-    );
-    results.push(...batchResults);
+var byHashAsc = (a, b) => a.localeCompare(b);
+var order = (offers) => {
+  return offers.sort((a, b) => byHashAsc(a.hash, b.hash));
+};
+var encode3 = (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.toString(),
+    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 = pako.gzip(JSON.stringify([tree.root, ...offersPayload]));
+  const encoded = new Uint8Array(1 + compressed.length);
+  encoded[0] = VERSION;
+  encoded.set(compressed, 1);
+  return viem.bytesToHex(encoded);
+};
+var assertRoot = (root, offers) => {
+  const tree = from7(offers);
+  if (root !== tree.root) {
+    throw new Error(`Invalid root: expected ${tree.root}, got ${root}`);
   }
-  return results;
-}
-
-// src/utils/lazy.ts
-function lazy(pollFn) {
-  return () => async function* () {
-    let active = true;
-    let resolveNext = null;
-    const queue = [];
-    const wait2 = () => new Promise((resolve) => {
-      resolveNext = resolve;
-    });
-    const emit = (item) => {
-      queue.push(item);
-      resolveNext?.();
-      resolveNext = null;
-    };
-    let unpoll = null;
-    const stop = () => {
-      active = false;
-      unpoll?.();
-      resolveNext?.();
-      resolveNext = null;
-    };
-    unpoll = pollFn(emit, { stop });
-    try {
-      while (active) {
-        if (queue.length === 0) await wait2();
-        while (queue.length > 0 && active) yield queue.shift();
-      }
-    } finally {
-      stop();
-    }
-  }();
-}
-
-// src/utils/wait.ts
-async function wait(time) {
-  return new Promise((res) => setTimeout(res, time));
-}
-
-// src/utils/poll.ts
-function poll(fn, { interval }) {
-  let active = true;
-  const unwatch = () => active = false;
-  const watch2 = async () => {
-    await wait(interval);
-    const poll2 = async () => {
-      if (!active) return;
-      await fn({ unpoll: unwatch });
-      await wait(interval);
-      poll2();
-    };
-    poll2();
-  };
-  watch2();
-  return unwatch;
-}
-
-// src/utils/time.ts
-var time_exports = {};
-__export(time_exports, {
-  max: () => max2,
-  now: () => now
-});
-function now() {
-  return Math.floor(Date.now() / 1e3);
-}
-function max2() {
-  return 864e16;
-}
+};
+var decode3 = (encoded) => {
+  const bytes = 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 payload = bytes.slice(1);
+  const decoded = pako.ungzip(payload, { to: "string" });
+  const data = JSON.parse(decoded);
+  const root = data[0];
+  const offers = data.slice(1).map((o) => OfferSchema({ omitConsumed: true, omitBlockNumber: true }).parse(o));
+  const tree = from7(offers);
+  if (root !== tree.root) {
+    throw new Error(`Invalid root: expected ${tree.root}, got ${root}`);
+  }
+  return tree;
+};
 
 // src/core/Offer.ts
-var OfferHashSchema = z7__namespace.string().regex(/^0x[0-9a-fA-F]{64}$/, {
+var StatusCode = /* @__PURE__ */ ((StatusCode2) => {
+  StatusCode2["VALID"] = "VALID";
+  StatusCode2["NOT_ENOUGH_LIQUIDITY"] = "NOT_ENOUGH_LIQUIDITY";
+  return StatusCode2;
+})(StatusCode || {});
+var OfferHashSchema = z9__namespace.string().regex(/^0x[0-9a-fA-F]{64}$/, {
   message: "Hash must be a valid 32-byte hex string"
 }).transform(transformHex);
 var OfferSchema = (parameters) => {
-  const { omitHash = false } = parameters || {};
-  const now2 = time_exports.now();
-  let base = z7__namespace.object({
-    offering: z7__namespace.string().transform(transformAddress),
-    assets: z7__namespace.bigint({ coerce: true }).min(0n).max(viem.maxUint256),
-    rate: z7__namespace.bigint({ coerce: true }).min(0n).max(viem.maxUint256),
+  const { omitHash = false, omitConsumed = false, omitBlockNumber = false } = parameters || {};
+  let base = z9__namespace.object({
+    offering: z9__namespace.string().transform(transformAddress),
+    assets: z9__namespace.bigint({ coerce: true }).min(0n).max(viem.maxUint256),
+    rate: z9__namespace.bigint({ coerce: true }).min(0n).max(viem.maxUint256),
     maturity: MaturitySchema,
-    expiry: z7__namespace.number().int().min(now2, { message: "Expiry must be set to a future date" }).max(Number.MAX_SAFE_INTEGER),
-    start: z7__namespace.number().int().max(Number.MAX_SAFE_INTEGER),
-    nonce: z7__namespace.bigint({ coerce: true }).min(0n).max(viem.maxUint256),
-    buy: z7__namespace.boolean(),
-    chainId: z7__namespace.bigint({ coerce: true }).min(0n).max(viem.maxUint256),
-    loanToken: z7__namespace.string().transform(transformAddress),
+    expiry: z9__namespace.number().int().max(Number.MAX_SAFE_INTEGER),
+    start: z9__namespace.number().int().max(Number.MAX_SAFE_INTEGER),
+    nonce: z9__namespace.bigint({ coerce: true }).min(0n).max(viem.maxUint256),
+    buy: z9__namespace.boolean(),
+    chainId: z9__namespace.bigint({ coerce: true }).min(0n).max(viem.maxUint256),
+    loanToken: z9__namespace.string().transform(transformAddress),
     collaterals: CollateralsSchema,
-    callback: z7__namespace.object({
-      address: z7__namespace.string().transform(transformAddress),
-      data: z7__namespace.string().transform(transformHex),
-      gasLimit: z7__namespace.bigint({ coerce: true }).min(0n).max(viem.maxUint256)
+    callback: z9__namespace.object({
+      address: z9__namespace.string().transform(transformAddress),
+      data: z9__namespace.string().transform(transformHex),
+      gasLimit: z9__namespace.bigint({ coerce: true }).min(0n).max(viem.maxUint256)
     }),
-    consumed: z7__namespace.bigint({ coerce: true }).min(0n).max(viem.maxUint256),
-    blockNumber: z7__namespace.number().int().max(Number.MAX_SAFE_INTEGER),
-    signature: z7__namespace.string().regex(/^0x[0-9a-fA-F]{130}$/, {
+    signature: z9__namespace.string().regex(/^0x[0-9a-fA-F]{130}$/, {
       message: "Signature must be a valid 65-byte hex string"
     }).transform(transformHex).optional()
   });
+  if (!omitConsumed)
+    base = base.extend({ consumed: z9__namespace.bigint({ coerce: true }).min(0n).max(viem.maxUint256) });
+  if (!omitBlockNumber)
+    base = base.extend({ blockNumber: z9__namespace.number().int().max(Number.MAX_SAFE_INTEGER) });
   if (!omitHash) base = base.extend({ hash: OfferHashSchema });
   return base.refine((data) => data.start < data.expiry, {
     message: "Start must be before expiry",
@@ -1274,7 +1873,7 @@ var OfferSchema = (parameters) => {
     path: ["expiry"]
   });
 };
-function from7(input) {
+function from8(input) {
   try {
     const parsedOffer = OfferSchema({ omitHash: true }).parse(input);
     const parsedHash = OfferHashSchema.parse(hash(parsedOffer));
@@ -1287,44 +1886,94 @@ function from7(input) {
   }
 }
 function fromSnakeCase3(input) {
-  return from7(fromSnakeCase(input));
+  return from8(fromSnakeCase(input));
 }
 function toSnakeCase2(offer) {
   return toSnakeCase(offer);
 }
-function random2() {
-  const loanToken = accounts.privateKeyToAccount(accounts.generatePrivateKey()).address;
-  const maturity = from5("end_of_month");
-  const expiry = from5("end_of_week") - 1;
-  const lltv = from3(0.965);
-  const offer = from7({
-    offering: accounts.privateKeyToAccount(accounts.generatePrivateKey()).address,
-    assets: BigInt(Math.floor(Math.random() * 1e6)),
-    rate: BigInt(Math.floor(Math.random() * 1e6)),
-    maturity,
-    expiry,
-    start: expiry - 10,
+function random3(config) {
+  const chain2 = config?.chains ? config.chains[Math.floor(Math.random() * config.chains.length)] : chains.ethereum;
+  const loanToken = config?.loanTokens ? config.loanTokens[Math.floor(Math.random() * config.loanTokens.length)] : accounts.privateKeyToAccount(accounts.generatePrivateKey()).address;
+  const collateralCandidates = config?.collateralTokens ? config.collateralTokens.filter((a) => a !== loanToken) : [accounts.privateKeyToAccount(accounts.generatePrivateKey()).address];
+  const collateralAsset = collateralCandidates[Math.floor(Math.random() * collateralCandidates.length)];
+  const maturityOption = weightedChoice([
+    ["end_of_month", 1],
+    ["end_of_next_month", 1]
+  ]);
+  const maturity2 = config?.maturity ?? from5(maturityOption);
+  const lltv = from3(
+    weightedChoice([
+      [0.385, 1],
+      [0.5, 1],
+      [0.625, 2],
+      [0.77, 8],
+      [0.86, 10],
+      [0.915, 8],
+      [0.945, 6],
+      [0.965, 4],
+      [0.98, 2]
+    ])
+  );
+  const buy = config?.buy !== void 0 ? config.buy : Math.random() > 0.5;
+  const ONE = 1000000000000000000n;
+  const qMin = buy ? 16 : 4;
+  const qMax = buy ? 32 : 16;
+  const len = qMax - qMin + 1;
+  const ratePairs = Array.from(
+    { length: len },
+    (_, idx) => {
+      const q = qMin + idx;
+      const scaledRate = BigInt(q) * (ONE / 4n);
+      const weight = buy ? 1 + idx : 1 + (len - 1 - idx);
+      return [scaledRate, weight];
+    }
+  );
+  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() * (1e6 - 100 + 1)));
+  const assetsScaled = config?.assets ?? amountBase * unit;
+  const consumed = config?.consumed !== void 0 ? config.consumed : Math.random() < 0.8 ? 0n : assetsScaled * BigInt(1 + Math.floor(Math.random() * 900)) / 1000n;
+  const callbackBySide = (() => {
+    if (buy) return { address: viem.zeroAddress, data: "0x", gasLimit: 0n };
+    const sellCallbackAddress = "0x3333333333333333333333333333333333333333";
+    const amount = assetsScaled * 1000000000000000000000n;
+    const data = encodeSellERC20Callback({
+      collaterals: [collateralAsset],
+      amounts: [amount]
+    });
+    return { address: sellCallbackAddress, data, gasLimit: 0n };
+  })();
+  const offer = from8({
+    offering: config?.offering ?? accounts.privateKeyToAccount(accounts.generatePrivateKey()).address,
+    assets: assetsScaled,
+    rate,
+    maturity: maturity2,
+    expiry: config?.expiry ?? maturity2 - 1,
+    start: config?.start ?? maturity2 - 10,
     nonce: BigInt(Math.floor(Math.random() * 1e6)),
-    buy: Math.random() > 0.5,
-    chainId: 1n,
+    buy,
+    chainId: chain2.id,
     loanToken,
-    collaterals: [
-      from4({
-        asset: viem.zeroAddress,
-        oracle: viem.zeroAddress,
-        lltv
-      })
-    ],
-    callback: {
-      address: viem.zeroAddress,
-      data: "0x",
-      gasLimit: 0n
-    },
-    consumed: 0n,
+    collaterals: config?.collaterals ?? Array.from({ length: Math.floor(Math.random() * 3) + 1 }, () => ({
+      ...random(),
+      lltv
+    })).sort((a, b) => a.asset.localeCompare(b.asset)),
+    callback: config?.callback ?? callbackBySide,
+    consumed,
     blockNumber: Math.floor(Math.random() * Number.MAX_SAFE_INTEGER)
   });
   return offer;
 }
+var weightedChoice = (pairs) => {
+  const total = pairs.reduce((sum, [, weight]) => sum + weight, 0);
+  let roll = Math.random() * total;
+  for (const [value, weight] of pairs) {
+    roll -= weight;
+    if (roll < 0) return value;
+  }
+  return pairs[0][0];
+};
 var domain = (chainId) => ({
   chainId,
   verifyingContract: viem.zeroAddress
@@ -1357,31 +2006,16 @@ var types = {
     { name: "gasLimit", type: "uint256" }
   ]
 };
-function sign(offer, wallet) {
+async function sign(offers, wallet) {
   if (!wallet.account) throw new AccountNotSetError();
-  return wallet.signTypedData({
+  return wallet.signMessage({
     account: wallet.account,
-    domain: domain(offer.chainId),
-    types,
-    primaryType: "Offer",
-    message: {
-      offering: offer.offering.toLowerCase(),
-      assets: offer.assets,
-      rate: offer.rate,
-      maturity: BigInt(offer.maturity),
-      expiry: BigInt(offer.expiry),
-      nonce: offer.nonce,
-      buy: offer.buy,
-      loanToken: offer.loanToken.toLowerCase(),
-      collaterals: offer.collaterals,
-      callback: {
-        address: offer.callback.address.toLowerCase(),
-        data: offer.callback.data,
-        gasLimit: offer.callback.gasLimit
-      }
-    }
+    message: { raw: signatureMsg(offers) }
   });
 }
+function signatureMsg(offers) {
+  return from7(offers).root;
+}
 function hash(offer) {
   return viem.hashTypedData({
     domain: domain(offer.chainId),
@@ -1446,7 +2080,7 @@ var OfferAbi = [
   },
   { name: "signature", type: "bytes" }
 ];
-function encode(offer) {
+function encode4(offer) {
   return viem.encodeAbiParameters(OfferAbi, [
     offer.offering,
     offer.assets,
@@ -1463,14 +2097,14 @@ function encode(offer) {
     offer.signature ?? "0x"
   ]);
 }
-function decode(data, blockNumber) {
+function decode4(data, blockNumber) {
   let decoded;
   try {
     decoded = viem.decodeAbiParameters(OfferAbi, data);
   } catch (error) {
     throw new InvalidOfferError(error);
   }
-  const offer = from7({
+  const offer = from8({
     offering: decoded[0],
     assets: decoded[1],
     rate: decoded[2],
@@ -1538,20 +2172,20 @@ var Quote_exports = {};
 __export(Quote_exports, {
   InvalidQuoteError: () => InvalidQuoteError,
   QuoteSchema: () => QuoteSchema,
-  from: () => from8,
+  from: () => from9,
   fromSnakeCase: () => fromSnakeCase4,
-  random: () => random3
+  random: () => random4
 });
-var QuoteSchema = z7__namespace.object({
-  obligationId: z7__namespace.string().transform(transformHex),
-  ask: z7__namespace.object({
-    rate: z7__namespace.bigint({ coerce: true }).min(0n).max(viem.maxUint256)
+var QuoteSchema = z9__namespace.object({
+  obligationId: z9__namespace.string().transform(transformHex),
+  ask: z9__namespace.object({
+    rate: z9__namespace.bigint({ coerce: true }).min(0n).max(viem.maxUint256)
   }),
-  bid: z7__namespace.object({
-    rate: z7__namespace.bigint({ coerce: true }).min(0n).max(viem.maxUint256)
+  bid: z9__namespace.object({
+    rate: z9__namespace.bigint({ coerce: true }).min(0n).max(viem.maxUint256)
   })
 });
-function from8(parameters) {
+function from9(parameters) {
   try {
     const parsedQuote = QuoteSchema.parse(parameters);
     return {
@@ -1564,10 +2198,10 @@ function from8(parameters) {
   }
 }
 function fromSnakeCase4(snake) {
-  return from8(fromSnakeCase(snake));
+  return from9(fromSnakeCase(snake));
 }
-function random3() {
-  return from8({
+function random4() {
+  return from9({
     obligationId: Obligation_exports.id(Obligation_exports.random()),
     ask: {
       rate: BigInt(Math.floor(Math.random() * 1e6))
@@ -1587,520 +2221,130 @@ var InvalidQuoteError = class extends BaseError {
 // src/core/types.ts
 var BrandTypeId = Symbol.for("mempool/Brand");
 
-// src/stores/utils/Cursor.ts
-var Cursor_exports = {};
-__export(Cursor_exports, {
-  decode: () => decode2,
-  encode: () => encode2,
-  validate: () => validate
-});
-function validate(cursor) {
-  if (!cursor || typeof cursor !== "object") {
-    throw new Error("Cursor must be an object");
+// src/client/Client.ts
+function connect(parameters) {
+  const u = new URL(parameters?.url || "https://router.morpho.dev");
+  if (u.protocol !== "http:" && u.protocol !== "https:") throw new InvalidUrlError(u.toString());
+  const headers = parameters?.headers ?? new Headers();
+  headers.set("Content-Type", "application/json");
+  parameters?.apiKey !== void 0 ? headers.set("X-API-Key", parameters.apiKey) : null;
+  const config = { url: u, headers };
+  const apiClient = createOpenApiFetchClient__default.default({
+    baseUrl: config.url.toString(),
+    headers: config.headers
+  });
+  return {
+    ...config,
+    getOffers: (parameters2) => getOffers(apiClient, parameters2),
+    getObligations: (parameters2) => getObligations(apiClient, parameters2)
+  };
+}
+async function getOffers(apiClient, parameters) {
+  const { data, error, response } = await apiClient.GET("/v1/offers", {
+    params: {
+      query: {
+        side: parameters.side,
+        obligation_id: parameters.obligationId,
+        cursor: parameters.cursor,
+        limit: parameters.limit
+      }
+    }
+  });
+  if (error !== void 0) {
+    switch (response.status) {
+      case 401:
+        throw new HttpUnauthorizedError();
+      case 403:
+        throw new HttpForbiddenError();
+      case 429:
+        throw new HttpRateLimitError();
+    }
+    throw new HttpGetApiFailedError(`GET request returned ${response.status}`, {
+      details: JSON.stringify(error)
+    });
   }
-  const c = cursor;
-  if (!["rate", "maturity", "expiry", "amount"].includes(c.sort)) {
-    throw new Error(
-      `Invalid sort field: ${c.sort}. Must be one of: rate, maturity, expiry, amount`
-    );
+  const offers = data?.data.map((item) => {
+    const { signature, ...rest } = item;
+    return Offer_exports.fromSnakeCase({
+      ...rest,
+      offering: item.offering,
+      maturity: Maturity_exports.from(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
+    });
+  }) ?? [];
+  return {
+    cursor: data?.cursor ?? null,
+    offers
+  };
+}
+async function getObligations(apiClient, parameters) {
+  const { data, error, response } = await apiClient.GET("/v1/obligations", {
+    params: {
+      query: {
+        cursor: parameters?.cursor,
+        limit: parameters?.limit
+      }
+    }
+  });
+  if (error !== void 0) {
+    switch (response.status) {
+      case 401:
+        throw new HttpUnauthorizedError();
+      case 403:
+        throw new HttpForbiddenError();
+      case 429:
+        throw new HttpRateLimitError();
+    }
+    throw new HttpGetApiFailedError(`GET request returned ${response.status}`, {
+      details: JSON.stringify(error)
+    });
   }
-  if (!["asc", "desc"].includes(c.dir)) {
-    throw new Error(`Invalid direction: ${c.dir}. Must be one of: asc, desc`);
+  const obligations = data?.data.map((item) => {
+    const obligation = Obligation_exports.fromSnakeCase({
+      chain_id: item.chain_id,
+      loan_token: item.loan_token,
+      collaterals: item.collaterals.map((collateral) => ({
+        asset: collateral.asset,
+        oracle: collateral.oracle,
+        lltv: collateral.lltv
+      })),
+      maturity: Maturity_exports.from(item.maturity)
+    });
+    const { obligationId: _, ...returned } = {
+      id: () => Obligation_exports.id(obligation),
+      ...obligation,
+      ...Quote_exports.fromSnakeCase({ obligation_id: item.id, ask: item.ask, bid: item.bid })
+    };
+    return returned;
+  }) ?? [];
+  return {
+    cursor: data?.cursor ?? null,
+    obligations
+  };
+}
+var InvalidUrlError = class extends BaseError {
+  constructor(url) {
+    super(`URL "${url}" is not http/https.`);
+    __publicField(this, "name", "Router.InvalidUrlError");
   }
-  if (!/^0x[a-fA-F0-9]{64}$/.test(c.hash)) {
-    throw new Error(
-      `Invalid hash format: ${c.hash}. Must be a 64-character hex string starting with 0x`
-    );
-  }
-  const validations = {
-    rate: {
-      field: "rate",
-      type: "string",
-      pattern: /^\d+$/,
-      error: "numeric string"
-    },
-    amount: {
-      field: "assets",
-      type: "string",
-      pattern: /^\d+$/,
-      error: "numeric string"
-    },
-    maturity: {
-      field: "maturity",
-      type: "number",
-      validator: (val) => val > 0,
-      error: "positive number"
-    },
-    expiry: {
-      field: "expiry",
-      type: "number",
-      validator: (val) => val > 0,
-      error: "positive number"
-    }
-  };
-  const validation = validations[c.sort];
-  if (!validation) {
-    throw new Error(`Invalid sort field: ${c.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");
-    }
-  }
-  return true;
-}
-function encode2(c) {
-  return jsBase64.Base64.encodeURL(JSON.stringify(c));
-}
-function decode2(token) {
-  if (!token) return null;
-  const decoded = JSON.parse(jsBase64.Base64.decode(token));
-  validate(decoded);
-  return decoded;
-}
-
-// src/api/Schema/requests.ts
-var MAX_LIMIT = 100;
-var DEFAULT_LIMIT = 20;
-var PaginationQueryParams = z7__namespace.object({
-  cursor: z7__namespace.string().optional().refine(
-    (val) => {
-      if (!val) return true;
-      try {
-        const decoded = Cursor_exports.decode(val);
-        return decoded !== null;
-      } catch (_error) {
-        return false;
-      }
-    },
-    {
-      message: "Invalid cursor format. Must be a valid base64url-encoded cursor object"
-    }
-  ).meta({
-    description: "Pagination cursor in base64url-encoded format",
-    example: "eyJzb3J0IjoicHJpY2UiLCJkaXIiOiJkZXNjIiwicHJpY2UiOiIxMDAwMDAwMDAwMDAwMDAwMDAwIiwiaGFzaCI6IjB4ZGRmZDY4NTllM2UwODJkMTkzODlhMWFlYzFiZGFkN2U4ZDkyZDk2YjFhYTc5NDBkYTkxYTMxMjVkMzFlM2JlNWIifQ"
-  }),
-  limit: z7__namespace.string().regex(/^[1-9]\d*$/, {
-    message: "Limit must be a positive integer"
-  }).transform((val) => Number.parseInt(val, 10)).pipe(
-    z7__namespace.number().max(MAX_LIMIT, {
-      message: `Limit cannot exceed ${MAX_LIMIT}`
-    })
-  ).optional().default(DEFAULT_LIMIT).meta({
-    description: `Limit maximum: ${MAX_LIMIT}. Default: ${DEFAULT_LIMIT}`,
-    example: 10
-  })
-});
-var GetOffersQueryParams = z7__namespace.object({
-  ...PaginationQueryParams.shape,
-  side: z7__namespace.enum(["buy", "sell"]).meta({
-    description: "Side of the offer.",
-    example: "buy"
-  }),
-  obligation_id: z7__namespace.string({ error: "Obligation id is required and must be a valid 32-byte hex string" }).regex(/^0x[a-fA-F0-9]{64}$/, { error: "Obligation id must be a valid 32-byte hex string" }).transform((val) => val.toLowerCase()).meta({
-    description: "Offers obligation id",
-    example: "0x1234567890123456789012345678901234567890123456789012345678901234"
-  })
-});
-var GetObligationsQueryParams = z7__namespace.object({
-  ...PaginationQueryParams.shape,
-  cursor: z7__namespace.string().optional().meta({
-    description: "Obligation id cursor",
-    example: "0x1234567890123456789012345678901234567890123456789012345678901234"
-  })
-});
-var schemas = {
-  get_offers: GetOffersQueryParams,
-  get_obligations: GetObligationsQueryParams
-};
-function parse(action, query) {
-  return schemas[action].parse(query);
-}
-function safeParse(action, query, error) {
-  return schemas[action].safeParse(query, {
-    error
-  });
-}
-
-// src/api/Schema/openapi.ts
-var timestampExample = "2024-01-01T12:00:00.000Z";
-var cursorExample = "eyJvZmZzZXQiOjEwMH0";
-function makeSuccessResponse(parameters) {
-  const { dataSchema, dataDescription, dataExample, cursor } = parameters;
-  const withDataMeta = dataDescription ? dataSchema.meta({ description: dataDescription }) : dataSchema;
-  return v4.z.object({
-    status: v4.z.literal("success"),
-    cursor: v4.z.string().nullable(),
-    data: v4.z.any(),
-    meta: v4.z.object({
-      timestamp: v4.z.string()
-    })
-  }).extend({
-    data: withDataMeta
-  }).meta({
-    example: {
-      status: "success",
-      cursor,
-      data: dataExample,
-      meta: { timestamp: timestampExample }
-    }
-  });
-}
-var OffersSuccessResponseSchema = makeSuccessResponse({
-  dataSchema: v4.z.array(v4.z.any()),
-  dataDescription: "Offers matching the provided filters.",
-  dataExample: [toSnakeCase(Offer_exports.random())],
-  cursor: cursorExample
-});
-var ObligationsSuccessResponseSchema = makeSuccessResponse({
-  dataSchema: v4.z.array(v4.z.any()),
-  dataDescription: "Obligations known to the router.",
-  dataExample: [toSnakeCase(Obligation_exports.random())],
-  cursor: cursorExample
-});
-var RouterStatusSuccessResponseSchema = makeSuccessResponse({
-  dataSchema: RouterStatusResponse,
-  dataDescription: "Aggregated router status.",
-  dataExample: { status: "live" },
-  cursor: null
-});
-var CollectorsHealthSuccessResponseSchema = makeSuccessResponse({
-  dataSchema: CollectorsHealthResponse,
-  dataDescription: "Collectors health details and sync status.",
-  dataExample: [
-    {
-      name: "mempool_offers",
-      chain_id: "1",
-      block_number: 21345678,
-      updated_at: "2024-01-01T12:00:00.000Z",
-      lag: 0,
-      status: "live"
-    }
-  ],
-  cursor: null
-});
-var ChainsHealthSuccessResponseSchema = makeSuccessResponse({
-  dataSchema: ChainsHealthResponse,
-  dataDescription: "Latest processed block per chain.",
-  dataExample: [
-    {
-      chain_id: "1",
-      block_number: 21345678,
-      updated_at: "2024-01-01T12:00:00.000Z"
-    }
-  ],
-  cursor: null
-});
-var errorResponseSchema = v4.z.object({
-  status: v4.z.literal("error"),
-  error: v4.z.object({
-    code: v4.z.string(),
-    message: v4.z.string(),
-    details: v4.z.any().optional()
-  }),
-  meta: v4.z.object({
-    timestamp: v4.z.string()
-  })
-}).meta({
-  description: "Error response wrapper.",
-  example: {
-    status: "error",
-    error: {
-      code: "VALIDATION_ERROR",
-      message: "Invalid cursor format. Must be a valid base64url-encoded cursor object",
-      details: [
-        {
-          field: "cursor",
-          issue: "Invalid cursor format. Must be a valid base64url-encoded cursor object"
-        }
-      ]
-    },
-    meta: {
-      timestamp: timestampExample
-    }
-  }
-});
-var paths = {
-  "/v1/offers": {
-    get: {
-      summary: "Offers",
-      description: "Find offers that match specific criteria",
-      tags: ["Offers"],
-      requestParams: {
-        query: GetOffersQueryParams
-      },
-      responses: {
-        200: {
-          description: "Success",
-          content: {
-            "application/json": {
-              schema: OffersSuccessResponseSchema
-            }
-          }
-        },
-        400: {
-          description: "Bad Request",
-          content: {
-            "application/json": {
-              schema: errorResponseSchema
-            }
-          }
-        }
-      }
-    }
-  },
-  "/v1/obligations": {
-    get: {
-      summary: "Obligations",
-      description: "List obligations with pagination support",
-      tags: ["Obligations"],
-      requestParams: {
-        query: GetObligationsQueryParams
-      },
-      responses: {
-        200: {
-          description: "Success",
-          content: {
-            "application/json": {
-              schema: ObligationsSuccessResponseSchema
-            }
-          }
-        },
-        400: {
-          description: "Bad Request",
-          content: {
-            "application/json": {
-              schema: errorResponseSchema
-            }
-          }
-        }
-      }
-    }
-  },
-  "/v1/health": {
-    get: {
-      summary: "Router status",
-      description: "Retrieve the aggregated status of the router.",
-      tags: ["Health"],
-      responses: {
-        200: {
-          description: "Success",
-          content: {
-            "application/json": {
-              schema: RouterStatusSuccessResponseSchema
-            }
-          }
-        }
-      }
-    }
-  },
-  "/v1/health/collectors": {
-    get: {
-      summary: "Collectors health",
-      description: "Retrieve the block numbers processed by collectors and their sync status.",
-      tags: ["Health"],
-      responses: {
-        200: {
-          description: "Success",
-          content: {
-            "application/json": {
-              schema: CollectorsHealthSuccessResponseSchema
-            }
-          }
-        }
-      }
-    }
-  },
-  "/v1/health/chains": {
-    get: {
-      summary: "Chains health",
-      description: "Retrieve the latest block processed for each chain.",
-      tags: ["Health"],
-      responses: {
-        200: {
-          description: "Success",
-          content: {
-            "application/json": {
-              schema: ChainsHealthSuccessResponseSchema
-            }
-          }
-        }
-      }
-    }
-  }
-};
-var OpenApi = zodOpenapi.createDocument({
-  openapi: "3.1.0",
-  info: {
-    title: "Router API",
-    version: "1.0.0",
-    description: "API for the Morpho Router"
-  },
-  tags: [
-    {
-      name: "Offers"
-    },
-    {
-      name: "Obligations"
-    },
-    {
-      name: "Health"
-    }
-  ],
-  servers: [
-    {
-      url: "https://router.morpho.dev",
-      description: "Production server"
-    },
-    {
-      url: "http://localhost:7891",
-      description: "Local development server"
-    }
-  ],
-  paths
-});
-
-// src/client/Client.ts
-var Client_exports = {};
-__export(Client_exports, {
-  HttpForbiddenError: () => HttpForbiddenError,
-  HttpGetApiFailedError: () => HttpGetApiFailedError,
-  HttpRateLimitError: () => HttpRateLimitError,
-  HttpUnauthorizedError: () => HttpUnauthorizedError,
-  InvalidUrlError: () => InvalidUrlError,
-  connect: () => connect,
-  getObligations: () => getObligations,
-  getOffers: () => getOffers
-});
-function connect(options) {
-  const u = new URL(options?.url || "https://router.morpho.dev");
-  if (u.protocol !== "http:" && u.protocol !== "https:") {
-    throw new InvalidUrlError(u.toString());
-  }
-  const headers = options?.headers ?? new Headers();
-  headers.set("Content-Type", "application/json");
-  options?.apiKey !== void 0 ? headers.set("X-API-Key", options.apiKey) : null;
-  const config = {
-    url: u,
-    headers
-  };
-  return {
-    ...config,
-    getOffers: (parameters) => getOffers(config, parameters),
-    getObligations: (parameters) => getObligations(config, parameters)
-  };
-}
-async function getOffers(config, parameters) {
-  const url = new URL(`${config.url.toString()}v1/offers`);
-  url.searchParams.set("side", parameters.side);
-  url.searchParams.set("obligation_id", parameters.obligationId.toString());
-  if (parameters.cursor) {
-    url.searchParams.set("cursor", parameters.cursor);
-  }
-  if (parameters.limit !== void 0) {
-    url.searchParams.set("limit", parameters.limit.toString());
-  }
-  const { cursor: returnedCursor, data: offers } = await getApi(config, url);
-  const routerOffers = offers.map(Offer_exports.fromSnakeCase);
-  return {
-    cursor: returnedCursor,
-    offers: routerOffers
-  };
-}
-async function getObligations(config, parameters) {
-  const url = new URL(`${config.url.toString()}v1/obligations`);
-  if (parameters?.cursor !== void 0) {
-    url.searchParams.set("cursor", parameters.cursor);
-  }
-  if (parameters?.limit !== void 0) {
-    url.searchParams.set("limit", parameters.limit.toString());
-  }
-  const { cursor: returnedCursor, data: items } = await getApi(config, url);
-  const obligations = items.map((item) => {
-    const obligation = Obligation_exports.fromSnakeCase(item);
-    const { obligationId: _, ...returned } = {
-      id: () => Obligation_exports.id(obligation),
-      ...obligation,
-      ...Quote_exports.fromSnakeCase({ obligation_id: item.id, ask: item.ask, bid: item.bid })
-    };
-    return returned;
-  });
-  return {
-    cursor: returnedCursor,
-    obligations
-  };
-}
-async function getApi(config, url) {
-  const pathname = url.pathname;
-  let action;
-  switch (true) {
-    case pathname.includes("/v1/offers"):
-      action = "get_offers";
-      break;
-    case pathname.includes("/v1/obligations"):
-      action = "get_obligations";
-      break;
-    default:
-      throw new HttpGetApiFailedError("Unknown endpoint", {
-        details: `Unsupported path: ${pathname}`
-      });
-  }
-  const schemaParseResult = safeParse(action, Object.fromEntries(url.searchParams));
-  if (!schemaParseResult.success) {
-    throw new HttpGetApiFailedError(`Invalid URL parameters`, {
-      details: schemaParseResult.error.issues[0]?.message
-    });
-  }
-  const response = await fetch(url.toString(), {
-    method: "GET",
-    headers: config.headers
-  });
-  if (!response.ok) {
-    switch (response.status) {
-      case 401:
-        throw new HttpUnauthorizedError();
-      case 403:
-        throw new HttpForbiddenError();
-      case 429:
-        throw new HttpRateLimitError();
-    }
-    throw new HttpGetApiFailedError(`GET request returned ${response.status}`, {
-      details: await response.text()
-    });
-  }
-  return response.json();
-}
-var InvalidUrlError = class extends BaseError {
-  constructor(url) {
-    super(`URL "${url}" is not http/https.`);
-    __publicField(this, "name", "Router.InvalidUrlError");
-  }
-};
-var HttpUnauthorizedError = class extends BaseError {
-  constructor() {
-    super("Unauthorized.", {
-      metaMessages: ["Ensure that an API key is provided."]
-    });
-    __publicField(this, "name", "Router.HttpUnauthorizedError");
+};
+var HttpUnauthorizedError = class extends BaseError {
+  constructor() {
+    super("Unauthorized.", {
+      metaMessages: ["Ensure that an API key is provided."]
+    });
+    __publicField(this, "name", "Router.HttpUnauthorizedError");
   }
 };
 var HttpForbiddenError = class extends BaseError {
@@ -2130,13 +2374,21 @@ var HttpGetApiFailedError = class extends BaseError {
   }
 };
 
-// src/collectors/validations/Validation.ts
-var Validation_exports = {};
-__export(Validation_exports, {
-  run: () => run
+// src/gatekeeper/Gate.ts
+var Gate_exports = {};
+__export(Gate_exports, {
+  batch: () => batch2,
+  run: () => run,
+  single: () => single
 });
+function single(name, run2) {
+  return { kind: "single", name, run: run2 };
+}
+function batch2(name, run2) {
+  return { kind: "batch", name, run: run2 };
+}
 async function run(parameters) {
-  const { items, rules, ctx = {}, chunkSize } = parameters;
+  const { items, rules, chunkSize } = parameters;
   const issues = [];
   let validItems = items.slice();
   for (const rule of rules) {
@@ -2145,7 +2397,7 @@ async function run(parameters) {
     if (rule.kind === "single") {
       for (let i = 0; i < validItems.length; i++) {
         const item = validItems[i];
-        const issue = await rule.run(item, ctx);
+        const issue = await rule.run(item);
         if (issue) {
           issues.push({ ...issue, ruleName: rule.name, item });
           indicesToRemove.add(i);
@@ -2153,7 +2405,7 @@ async function run(parameters) {
       }
     } else if (rule.kind === "batch") {
       const exec = async (slice, offset) => {
-        const map = await rule.run(slice, ctx);
+        const map = await rule.run(slice);
         for (let i = 0; i < slice.length; i++) {
           const issue = map.get(i);
           if (issue !== void 0) {
@@ -2177,157 +2429,265 @@ async function run(parameters) {
   };
 }
 
-// src/collectors/validations/ValidationRule.ts
-var ValidationRule_exports = {};
-__export(ValidationRule_exports, {
-  batch: () => batch2,
-  morpho: () => morpho,
-  single: () => single
+// src/gatekeeper/GateConfig.ts
+var GateConfig_exports = {};
+__export(GateConfig_exports, {
+  assets: () => assets,
+  configs: () => configs,
+  getCallback: () => getCallback,
+  getCallbackAddresses: () => getCallbackAddresses,
+  getCallbackType: () => getCallbackType,
+  getCallbackTypeAddresses: () => getCallbackTypeAddresses
 });
-function single(name, run2) {
-  return { kind: "single", name, run: run2 };
+function getCallback(chain2, type) {
+  return configs[chain2].callbacks?.find((c) => c.type === type);
 }
-function batch2(name, run2) {
-  return { kind: "batch", name, run: run2 };
+function getCallbackType(chain2, address) {
+  return configs[chain2].callbacks?.find(
+    (c) => c.type !== "buy_with_empty_callback" /* BuyWithEmptyCallback */ && c.addresses.includes(address?.toLowerCase())
+  )?.type;
 }
-function morpho() {
-  const chainId = single("chain_id", (offer, { chain }) => {
-    if (chain.id !== offer.chainId) {
-      return {
-        message: `Chain ID ${offer.chainId} is not the same as the chain ID in the context (${chain.id})`
-      };
-    }
-  });
-  const loanToken = single("loan_token", (offer, { chain }) => {
-    const tokens = new Set(
-      Array.from(chain.whitelistedAssets.values()).map((a) => a.toLowerCase())
-    );
-    if (!tokens.has(offer.loanToken.toLowerCase())) {
-      return {
-        message: `Loan token ${offer.loanToken} is not whitelisted on chain ${offer.chainId}`
-      };
-    }
-  });
-  const expiry = single("expiry", (offer, _) => {
-    if (offer.expiry < Math.floor(Date.now() / 1e3)) {
-      return { message: "Expiry mismatch" };
-    }
-  });
-  const sellEmptyCallback = single(
-    "sell_offers_empty_callback",
-    (offer, _) => {
-      if (!offer.buy && offer.callback.data === "0x") {
-        return { message: "Sell offers require a non-empty callback." };
-      }
-    }
-  );
-  const buyNonEmptyCallback = single(
-    "buy_offers_non_empty_callback",
-    (offer, _) => {
-      if (offer.buy && offer.callback.data !== "0x") {
-        const allowed = new Set(
-          Callback_exports.WhitelistedCallbackAddresses[Callback_exports.CallbackType.BuyVaultV1Callback].map(
-            (a) => a.toLowerCase()
-          )
-        );
-        const callbackAddress = offer.callback.address?.toLowerCase();
-        if (!callbackAddress || !allowed.has(callbackAddress)) {
-          return {
-            message: "Buy offers with non-empty callback must use a whitelisted BuyVaultV1Callback."
-          };
-        }
-      }
+function getCallbackTypeAddresses(chain2, type) {
+  if (type === "buy_with_empty_callback" /* BuyWithEmptyCallback */) {
+    return [];
+  }
+  const match = configs[chain2].callbacks?.find((c) => c.type === type);
+  return match && "addresses" in match ? match.addresses : [];
+}
+var getCallbackAddresses = (chain2) => {
+  return configs[chain2].callbacks?.filter((c) => c.type !== "buy_with_empty_callback" /* BuyWithEmptyCallback */).flatMap((c) => c.addresses) ?? [];
+};
+var assets = {
+  [ChainId.ETHEREUM.toString()]: [
+    "0xA0b86991c6218b36c1d19D4a2e9Eb0cE3606eB48",
+    // USDC
+    "0x6B175474E89094C44Da98b954EedeAC495271d0F",
+    // DAI
+    "0xC02aaA39b223FE8D0A0e5C4F27eAD9083C756Cc2",
+    // WETH
+    "0x2260FAC5E5542a773Aa44fBCfeDf7C193bc2C599"
+    // WBTC
+  ],
+  [ChainId.BASE.toString()]: [
+    "0x833589fCD6eDb6E08f4c7C32D4f71b54bdA02913",
+    // USDC
+    "0x50c5725949A6F0c72E6C4a641F24049A917DB0Cb",
+    // DAI
+    "0x4200000000000000000000000000000000000006",
+    // WETH
+    "0x2260FAC5E5542a773Aa44fBCfeDf7C193bc2C599"
+    // WBTC
+  ],
+  [ChainId["ETHEREUM-VIRTUAL-TESTNET"].toString()]: [
+    "0xA0b86991c6218b36c1d19D4a2e9Eb0cE3606eB48",
+    // USDC
+    "0x6B175474E89094C44Da98b954EedeAC495271d0F",
+    // DAI
+    "0xC02aaA39b223FE8D0A0e5C4F27eAD9083C756Cc2",
+    // WETH
+    "0x2260FAC5E5542a773Aa44fBCfeDf7C193bc2C599"
+    // WBTC
+  ],
+  [ChainId.ANVIL.toString()]: [
+    "0xA0b86991c6218b36c1d19D4a2e9Eb0cE3606eB48",
+    // USDC
+    "0x6B175474E89094C44Da98b954EedeAC495271d0F",
+    // DAI
+    "0xC02aaA39b223FE8D0A0e5C4F27eAD9083C756Cc2",
+    // WETH
+    "0x2260FAC5E5542a773Aa44fBCfeDf7C193bc2C599"
+    // WBTC
+  ]
+};
+var configs = {
+  ethereum: {
+    callbacks: [
+      {
+        type: "buy_vault_v1_callback" /* BuyVaultV1Callback */,
+        addresses: [
+          "0x3333333333333333333333333333333333333333",
+          "0x4444444444444444444444444444444444444444"
+        ],
+        vaultFactories: [
+          "0xA9c3D3a366466Fa809d1Ae982Fb2c46E5fC41101",
+          //v1.0
+          "0x1897A8997241C1cD4bD0698647e4EB7213535c24"
+          //v1.1
+        ]
+      },
+      {
+        type: "sell_erc20_callback" /* SellERC20Callback */,
+        addresses: [
+          "0x1111111111111111111111111111111111111111",
+          "0x2222222222222222222222222222222222222222"
+        ]
+      },
+      { type: "buy_with_empty_callback" /* BuyWithEmptyCallback */ }
+    ],
+    maturities: ["end_of_month" /* EndOfMonth */, "end_of_next_month" /* EndOfNextMonth */]
+  },
+  base: {
+    callbacks: [
+      {
+        type: "buy_vault_v1_callback" /* BuyVaultV1Callback */,
+        addresses: [
+          "0x3333333333333333333333333333333333333333",
+          "0x4444444444444444444444444444444444444444"
+        ],
+        vaultFactories: [
+          "0xA9c3D3a366466Fa809d1Ae982Fb2c46E5fC41101",
+          //v1.0
+          "0xFf62A7c278C62eD665133147129245053Bbf5918"
+          //v1.1
+        ]
+      },
+      {
+        type: "sell_erc20_callback" /* SellERC20Callback */,
+        addresses: [
+          "0x1111111111111111111111111111111111111111",
+          "0x2222222222222222222222222222222222222222"
+        ]
+      },
+      { type: "buy_with_empty_callback" /* BuyWithEmptyCallback */ }
+    ],
+    maturities: ["end_of_month" /* EndOfMonth */, "end_of_next_month" /* EndOfNextMonth */]
+  },
+  "ethereum-virtual-testnet": {
+    callbacks: [
+      {
+        type: "buy_vault_v1_callback" /* BuyVaultV1Callback */,
+        addresses: [
+          "0x3333333333333333333333333333333333333333",
+          "0x4444444444444444444444444444444444444444"
+        ],
+        vaultFactories: [
+          "0xA9c3D3a366466Fa809d1Ae982Fb2c46E5fC41101",
+          //v1.0
+          "0x1897A8997241C1cD4bD0698647e4EB7213535c24"
+          //v1.1
+        ]
+      },
+      {
+        type: "sell_erc20_callback" /* SellERC20Callback */,
+        addresses: [
+          "0x1111111111111111111111111111111111111111",
+          "0x2222222222222222222222222222222222222222"
+        ]
+      },
+      { type: "buy_with_empty_callback" /* BuyWithEmptyCallback */ }
+    ],
+    maturities: ["end_of_month" /* EndOfMonth */, "end_of_next_month" /* EndOfNextMonth */]
+  },
+  anvil: {
+    callbacks: [
+      {
+        type: "buy_vault_v1_callback" /* BuyVaultV1Callback */,
+        addresses: [
+          "0x3333333333333333333333333333333333333333",
+          "0x4444444444444444444444444444444444444444"
+        ],
+        vaultFactories: [
+          "0xA9c3D3a366466Fa809d1Ae982Fb2c46E5fC41101",
+          //v1.0
+          "0x1897A8997241C1cD4bD0698647e4EB7213535c24"
+          //v1.1
+        ]
+      },
+      {
+        type: "sell_erc20_callback" /* SellERC20Callback */,
+        addresses: [
+          "0x1111111111111111111111111111111111111111",
+          "0x2222222222222222222222222222222222222222"
+        ]
+      },
+      { type: "buy_with_empty_callback" /* BuyWithEmptyCallback */ }
+    ],
+    maturities: ["end_of_month" /* EndOfMonth */, "end_of_next_month" /* EndOfNextMonth */]
+  }
+};
+
+// src/gatekeeper/Gatekeeper.ts
+var Gatekeeper_exports = {};
+__export(Gatekeeper_exports, {
+  create: () => create
+});
+function create(parameters) {
+  return {
+    isAllowed: async (offers) => {
+      return await run({
+        items: offers,
+        rules: parameters.rules
+      });
     }
-  );
-  const sellNonWhitelistedCallback = single(
-    "sell_offers_non_whitelisted_callback",
-    (offer, _) => {
-      if (!offer.buy && offer.callback.data !== "0x") {
-        const allowed = new Set(
-          Callback_exports.WhitelistedCallbackAddresses[Callback_exports.CallbackType.SellERC20Callback].map(
-            (a) => a.toLowerCase()
-          )
-        );
-        const callbackAddress = offer.callback.address?.toLowerCase();
-        if (!callbackAddress || !allowed.has(callbackAddress)) {
-          return { message: "Sell offer callback address is not whitelisted." };
-        }
-      }
+  };
+}
+
+// src/gatekeeper/Rules.ts
+var Rules_exports = {};
+__export(Rules_exports, {
+  callback: () => callback,
+  chain: () => chain,
+  maturity: () => maturity,
+  token: () => token,
+  validity: () => validity
+});
+function validity(parameters) {
+  const { chain: chain2, client } = parameters;
+  const sellErc20CallbackInvalid = single("sell_erc20_callback_invalid", (offer) => {
+    const callbackType = getCallbackType(chain2.name, offer.callback.address);
+    if (callbackType !== Callback_exports.CallbackType.SellERC20Callback) {
+      return;
     }
-  );
-  const sellCallbackDataInvalid = single(
-    "sell_offers_callback_data_invalid",
-    (offer, _) => {
-      if (!offer.buy && offer.callback.data !== "0x") {
-        try {
-          const decoded = Callback_exports.decodeSellERC20Callback(offer.callback.data);
-          if (decoded.length === 0) {
-            return { message: "Sell offer callback data must include at least one collateral." };
-          }
-        } catch (_2) {
-          return { message: "Sell offer callback data cannot be decoded." };
-        }
-      }
+    const decoded = Callback_exports.decode(callbackType, offer.callback.data);
+    if (decoded.length === 0) {
+      return { message: "Callback data cannot be decoded or is empty." };
     }
-  );
-  const sellCallbackCollateralInvalid = single(
-    "sell_offers_callback_collateral_invalid",
-    (offer, _) => {
-      if (!offer.buy && offer.callback.data !== "0x") {
-        try {
-          const decoded = Callback_exports.decodeSellERC20Callback(offer.callback.data);
-          const offerCollaterals = new Set(
-            offer.collaterals.map((c) => c.asset.toLowerCase())
-          );
-          for (const { collateral } of decoded) {
-            if (!offerCollaterals.has(collateral.toLowerCase())) {
-              return { message: "Sell callback collateral is not part of offer collaterals." };
-            }
-          }
-        } catch (_2) {
-        }
+    if (callbackType === Callback_exports.CallbackType.SellERC20Callback) {
+      const offerCollaterals = new Set(
+        offer.collaterals.map((c) => c.asset.toLowerCase())
+      );
+      if (decoded.length !== offer.collaterals.length) {
+        return {
+          message: `Sell callback collateral length mismatch. Expected ${offer.collaterals.length}, got ${decoded.length}.`
+        };
       }
-    }
-  );
-  const buyCallbackDataInvalid = single(
-    "buy_offers_callback_data_invalid",
-    (offer, _) => {
-      if (offer.buy && offer.callback.data !== "0x") {
-        try {
-          const decoded = Callback_exports.decodeBuyVaultV1Callback(offer.callback.data);
-          if (decoded.length === 0) {
-            return { message: "Buy offer callback data must include at least one vault." };
-          }
-        } catch (_2) {
-          return { message: "Buy offer callback data cannot be decoded." };
+      for (const { collateral } of decoded) {
+        if (!offerCollaterals.has(collateral.toLowerCase())) {
+          return { message: "Sell callback collateral is not part of offer collaterals." };
         }
       }
     }
-  );
+  });
   const buyCallbackVaultInvalid = batch2(
     "buy_offers_callback_vault_invalid",
-    async (offers, { client, chain }) => {
+    async (offers) => {
       const validationIssues = /* @__PURE__ */ new Map();
       const offersByVaultAddress = /* @__PURE__ */ new Map();
       for (let i = 0; i < offers.length; i++) {
         const offer = offers[i];
-        if (offer.buy && offer.callback.data !== "0x") {
-          try {
-            const callbackVaults = Callback_exports.decodeBuyVaultV1Callback(offer.callback.data);
-            for (const { vault } of callbackVaults) {
-              const normalizedVaultAddress = vault.toLowerCase();
-              if (!offersByVaultAddress.has(normalizedVaultAddress)) {
-                offersByVaultAddress.set(normalizedVaultAddress, []);
-              }
-              offersByVaultAddress.get(normalizedVaultAddress).push({ index: i, offer });
+        const callbackType = getCallbackType(chain2.name, offer.callback.address);
+        if (callbackType !== Callback_exports.CallbackType.BuyVaultV1Callback) {
+          continue;
+        }
+        try {
+          const callbackVaults = Callback_exports.decodeBuyVaultV1Callback(offer.callback.data);
+          for (const { vault } of callbackVaults) {
+            const normalizedVaultAddress = vault.toLowerCase();
+            if (!offersByVaultAddress.has(normalizedVaultAddress)) {
+              offersByVaultAddress.set(normalizedVaultAddress, []);
             }
-          } catch (_) {
+            offersByVaultAddress.get(normalizedVaultAddress).push({ index: i, offer });
           }
+        } catch (_) {
         }
       }
       const uniqueVaultAddresses = Array.from(offersByVaultAddress.keys());
       if (uniqueVaultAddresses.length === 0) return validationIssues;
-      const whitelistedFactories = Object.values(chain.vaultV1Factory);
+      const allowedFactories = getCallback(
+        chain2.name,
+        Callback_exports.CallbackType.BuyVaultV1Callback
+      )?.vaultFactories.map((f) => f.toLowerCase());
+      if (!allowedFactories) return validationIssues;
       const multicallContracts = [];
       for (const vaultAddress of uniqueVaultAddresses) {
         multicallContracts.push({
@@ -2335,7 +2695,7 @@ function morpho() {
           abi: Abi_exports.ERC4626,
           functionName: "asset"
         });
-        for (const factoryAddress of whitelistedFactories) {
+        for (const factoryAddress of allowedFactories) {
           multicallContracts.push({
             address: factoryAddress,
             abi: Abi_exports.MetaMorphoFactory,
@@ -2350,7 +2710,7 @@ function morpho() {
       });
       const vaultAssetByAddress = /* @__PURE__ */ new Map();
       const registeredVaults = /* @__PURE__ */ new Set();
-      const numberOfFactories = whitelistedFactories.length;
+      const numberOfFactories = allowedFactories.length;
       let resultIndex = 0;
       for (const vaultAddress of uniqueVaultAddresses) {
         const assetCallResult = multicallResults[resultIndex++];
@@ -2409,30 +2769,61 @@ function morpho() {
       return validationIssues;
     }
   );
-  const maturity = single("maturity", (offer, _) => {
-    const allowedMaturities = [Maturity_exports.from("end_of_month"), Maturity_exports.from("end_of_next_month")];
-    if (!allowedMaturities.includes(offer.maturity)) {
-      return {
-        message: `Maturity must be end of current month (${allowedMaturities[0]}) or end of next month (${allowedMaturities[1]}). Got: ${offer.maturity}`
-      };
+  const expiry = single("expiry", (offer) => {
+    if (offer.expiry < Math.floor(Date.now() / 1e3)) {
+      return { message: "Expiry mismatch" };
     }
   });
-  return [
-    chainId,
-    loanToken,
-    expiry,
-    maturity,
-    // note: callback rules should be the last ones, since they do not mean that the offer is forever invalid
-    // integrators should be able to choose if they want to keep the offer or not
-    sellEmptyCallback,
-    buyNonEmptyCallback,
-    sellNonWhitelistedCallback,
-    sellCallbackDataInvalid,
-    sellCallbackCollateralInvalid,
-    buyCallbackDataInvalid,
-    buyCallbackVaultInvalid
-  ];
+  return [expiry, sellErc20CallbackInvalid, buyCallbackVaultInvalid];
 }
+var chain = ({ chain: chain2 }) => single("chain_id", (offer) => {
+  if (chain2.id !== offer.chainId) {
+    return {
+      message: `Chain ID ${offer.chainId} is not the same as the chain ID in the context (${chain2.id})`
+    };
+  }
+});
+var maturity = ({ maturities }) => single("maturity", (offer) => {
+  const allowedMaturities = maturities.map((m) => Maturity_exports.from(m));
+  if (!allowedMaturities.includes(offer.maturity)) {
+    return {
+      message: `Maturity must be end of current month (${allowedMaturities[0]}) or end of next month (${allowedMaturities[1]}). Got: ${offer.maturity}`
+    };
+  }
+});
+var callback = ({
+  callbacks,
+  allowedAddresses
+}) => single("callback", (offer) => {
+  if (Callback_exports.isEmptyCallback(offer) && offer.buy && !callbacks?.find((c) => c === Callback_exports.CallbackType.BuyWithEmptyCallback)) {
+    return {
+      message: "Buy offers with empty callback not allowed."
+    };
+  }
+  if (Callback_exports.isEmptyCallback(offer) && !offer.buy) {
+    return {
+      message: "Sell offers require a non-empty callback."
+    };
+  }
+  if (!Callback_exports.isEmptyCallback(offer)) {
+    if (!allowedAddresses.includes(offer.callback.address?.toLowerCase())) {
+      return {
+        message: `Callback address ${offer.callback.address} is not allowed.`
+      };
+    }
+  }
+});
+var token = ({ assets: assets2 }) => single("token", (offer) => {
+  const allowedAssets = assets2?.map((asset) => asset.toLowerCase());
+  if (!allowedAssets || allowedAssets.length === 0) return { message: "No allowed assets" };
+  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" };
+  return void 0;
+});
 
 // src/mempool/MempoolClient.ts
 var MempoolClient_exports = {};
@@ -2441,7 +2832,7 @@ __export(MempoolClient_exports, {
 });
 var DEFAULT_BATCH_SIZE2 = 100;
 var DEFAULT_BLOCK_WINDOW2 = 100;
-function from9(parameters) {
+function from10(parameters) {
   const config = {
     client: parameters.client,
     mempoolAddress: parameters.mempoolAddress,
@@ -2450,24 +2841,24 @@ function from9(parameters) {
   return {
     add: (parameters2) => add(config, parameters2),
     get: (parameters2) => get(config, parameters2),
-    watch: (parameters2) => watch(config, parameters2),
     stream: (parameters2) => streamOffers(config, parameters2)
   };
 }
-async function add(config, parameters) {
-  const offer = Offer_exports.from(parameters.offer);
+async function add(config, offers) {
   if (!config.client.account) throw new WalletAccountNotSetError();
+  const tree = Tree_exports.from(offers.map((o) => Offer_exports.from(o)));
   const chainId = await getChainId(config.client);
-  if (BigInt(chainId) !== offer.chainId)
-    throw new ChainIdMismatchError(offer.chainId, BigInt(chainId));
+  for (const offer of tree.offers) {
+    if (BigInt(chainId) !== offer.chainId)
+      throw new ChainIdMismatchError(offer.chainId, BigInt(chainId));
+  }
   try {
-    const tx = await config.client.sendTransaction({
+    return await config.client.sendTransaction({
       chain: config.client.chain,
       account: config.client.account,
       to: config.mempoolAddress,
-      data: Offer_exports.encode(offer)
+      data: Tree_exports.encode(tree)
     });
-    return { offer, txHash: tx };
   } catch (error) {
     throw new ViemClientError(error instanceof Error ? error.message : "Unknown error");
   }
@@ -2477,40 +2868,17 @@ async function* get(config, parameters) {
     loanToken,
     blockNumberGte,
     blockNumberLte,
-    order = "desc",
+    order: order2 = "desc",
     options: { maxBatchSize = DEFAULT_BATCH_SIZE2 } = {}
   } = parameters || {};
   yield* streamOffers(config, {
     loanToken,
-    order,
+    order: order2,
     blockNumberGte,
     blockNumberLte,
     options: { maxBatchSize, blockWindow: config.blockWindow }
   });
 }
-function watch(config, parameters) {
-  const {
-    loanToken,
-    lastSyncedBlock,
-    polling: { interval = 3e4, maxBatchSize = DEFAULT_BATCH_SIZE2 } = {},
-    onOffers
-  } = parameters;
-  return poll(
-    async () => {
-      const blockNumberGte = await lastSyncedBlock();
-      const stream = streamOffers(config, {
-        loanToken,
-        order: "asc",
-        blockNumberGte,
-        options: { maxBatchSize, blockWindow: config.blockWindow }
-      });
-      for await (const { offers, blockNumber } of stream) {
-        await onOffers(offers, blockNumber);
-      }
-    },
-    { interval }
-  );
-}
 var chainIdCache = /* @__PURE__ */ new Map();
 var getChainId = async (client) => {
   if (chainIdCache.has(client.uid)) return chainIdCache.get(client.uid);
@@ -2523,7 +2891,7 @@ async function* streamOffers(config, parameters) {
     loanToken,
     blockNumberGte,
     blockNumberLte,
-    order = "desc",
+    order: order2 = "desc",
     options: { maxBatchSize = DEFAULT_BATCH_SIZE2, blockWindow = config.blockWindow } = {}
   } = parameters;
   const stream = Chain_exports.streamLogs({
@@ -2537,28 +2905,29 @@ async function* streamOffers(config, parameters) {
     },
     blockNumberGte,
     blockNumberLte,
-    order,
+    order: order2,
     options: { maxBatchSize, blockWindow }
   });
-  let blockNumber = order === "asc" ? blockNumberGte : blockNumberLte;
+  let blockNumber = order2 === "asc" ? blockNumberGte : blockNumberLte;
   for await (const { logs, blockNumber: newBlockNumber } of stream) {
     blockNumber = newBlockNumber;
     if (logs.length === 0) break;
-    let offersAndBlockNumbers = logs.map((log) => {
+    const offers = [];
+    for (const log of logs) {
+      if (!log) continue;
       const [payload] = viem.decodeAbiParameters([{ type: "bytes" }], log.data);
       try {
-        return { offer: Offer_exports.decode(payload, log.blockNumber), blockNumber: log.blockNumber };
+        const tree = Tree_exports.decode(payload);
+        for (const offer of tree.offers) {
+          if (loanToken && offer.loanToken.toLowerCase() !== loanToken.toLowerCase()) continue;
+          offers.push({ ...offer, blockNumber: Number(log.blockNumber) });
+        }
       } catch (_) {
-        return null;
       }
-    }).filter((item) => item !== null);
-    if (loanToken)
-      offersAndBlockNumbers = offersAndBlockNumbers.filter(
-        (o) => o.offer.loanToken.toLowerCase() === loanToken.toLowerCase()
-      );
-    if (offersAndBlockNumbers.length === 0) continue;
+    }
+    if (offers.length === 0) continue;
     yield {
-      offers: offersAndBlockNumbers.map((item) => item.offer),
+      offers,
       blockNumber
     };
   }
@@ -2586,7 +2955,127 @@ var ChainIdMismatchError = class extends BaseError {
 
 // src/mempool/MempoolClient.ts
 function connect2(parameters) {
-  return from9(parameters);
+  return from10(parameters);
+}
+
+// src/utils/index.ts
+var utils_exports = {};
+__export(utils_exports, {
+  BaseError: () => BaseError,
+  Time: () => time_exports,
+  batch: () => batch,
+  batchMulticall: () => batchMulticall,
+  fromSnakeCase: () => fromSnakeCase,
+  lazy: () => lazy,
+  max: () => max,
+  min: () => min,
+  poll: () => poll,
+  retry: () => retry,
+  stringifyBigint: () => stringifyBigint,
+  toSnakeCase: () => toSnakeCase,
+  wait: () => wait
+});
+
+// src/utils/retry.ts
+var retry = async (fn, attempts = 3, delayMs = 50) => {
+  let lastErr;
+  for (let i = 0; i < attempts; i++) {
+    try {
+      return await fn();
+    } catch (err) {
+      lastErr = err;
+      if (i < attempts - 1) await new Promise((r) => setTimeout(r, delayMs));
+    }
+  }
+  throw lastErr;
+};
+
+// src/utils/batchMulticall.ts
+async function batchMulticall(parameters) {
+  const { client, calls, batchSize, retryAttempts, retryDelayMs, blockNumber } = parameters;
+  const results = [];
+  for (const callsBatch of batch(calls, batchSize)) {
+    const batchResults = await retry(
+      () => client.multicall({
+        allowFailure: false,
+        contracts: callsBatch,
+        ...blockNumber ? { blockNumber } : {}
+      }),
+      retryAttempts,
+      retryDelayMs
+    );
+    results.push(...batchResults);
+  }
+  return results;
+}
+
+// src/utils/lazy.ts
+function lazy(pollFn) {
+  return () => async function* () {
+    let active = true;
+    let resolveNext = null;
+    const queue = [];
+    const wait2 = () => new Promise((resolve) => {
+      resolveNext = resolve;
+    });
+    const emit = (item) => {
+      queue.push(item);
+      resolveNext?.();
+      resolveNext = null;
+    };
+    let unpoll = null;
+    const stop = () => {
+      active = false;
+      unpoll?.();
+      resolveNext?.();
+      resolveNext = null;
+    };
+    unpoll = pollFn(emit, { stop });
+    try {
+      while (active) {
+        if (queue.length === 0) await wait2();
+        while (queue.length > 0 && active) yield queue.shift();
+      }
+    } finally {
+      stop();
+    }
+  }();
+}
+
+// src/utils/wait.ts
+async function wait(time) {
+  return new Promise((res) => setTimeout(res, time));
+}
+
+// src/utils/poll.ts
+function poll(fn, { interval }) {
+  let active = true;
+  const unwatch = () => active = false;
+  const watch = async () => {
+    await wait(interval);
+    const poll2 = async () => {
+      if (!active) return;
+      await fn({ unpoll: unwatch });
+      await wait(interval);
+      poll2();
+    };
+    poll2();
+  };
+  watch();
+  return unwatch;
+}
+
+// src/utils/time.ts
+var time_exports = {};
+__export(time_exports, {
+  max: () => max2,
+  now: () => now
+});
+function now() {
+  return Math.floor(Date.now() / 1e3);
+}
+function max2() {
+  return 864e16;
 }
 
 exports.Abi = Abi_exports;
@@ -2597,6 +3086,8 @@ exports.Collateral = Collateral_exports;
 exports.Cursor = Cursor_exports;
 exports.Errors = Errors_exports;
 exports.Format = Format_exports;
+exports.GateConfig = GateConfig_exports;
+exports.Gatekeeper = Gatekeeper_exports;
 exports.LLTV = LLTV_exports;
 exports.Liquidity = Liquidity_exports;
 exports.Maturity = Maturity_exports;
@@ -2606,9 +3097,10 @@ exports.Offer = Offer_exports;
 exports.Quote = Quote_exports;
 exports.RouterApi = Schema_exports;
 exports.RouterClient = Client_exports;
+exports.Rules = Rules_exports;
 exports.Time = time_exports;
+exports.Tree = Tree_exports;
 exports.Utils = utils_exports;
-exports.Validation = Validation_exports;
-exports.ValidationRule = ValidationRule_exports;
+exports.Validation = Gate_exports;
 //# sourceMappingURL=index.browser.js.map
 //# sourceMappingURL=index.browser.js.map