@morpho-dev/router 0.0.12 → 0.0.14

package/dist/index.browser.js

@@ -3,6 +3,8 @@
 var mempool = require('@morpho-dev/mempool');
 var chains$1 = require('viem/chains');
 var viem = require('viem');
+var v4 = require('zod/v4');
+var zodOpenapi = require('zod-openapi');
 
 var __defProp = Object.defineProperty;
 var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
@@ -66,9 +68,9 @@ var chains = {
   }
 };
 
-// src/core/index.ts
-var core_exports = {};
-__export(core_exports, {
+// src/core/Client.ts
+var Client_exports = {};
+__export(Client_exports, {
   HttpForbiddenError: () => HttpForbiddenError,
   HttpGetOffersFailedError: () => HttpGetOffersFailedError,
   HttpRateLimitError: () => HttpRateLimitError,
@@ -78,7 +80,647 @@ __export(core_exports, {
   get: () => get,
   match: () => match
 });
-var MAX_BATCH_SIZE = 100;
+
+// src/RouterOffer.ts
+var RouterOffer_exports = {};
+__export(RouterOffer_exports, {
+  InvalidRouterOfferError: () => InvalidRouterOfferError,
+  OfferStatusValues: () => OfferStatusValues,
+  RouterOfferSchema: () => RouterOfferSchema,
+  from: () => from,
+  fromSnakeCase: () => fromSnakeCase,
+  random: () => random,
+  toSnakeCase: () => toSnakeCase
+});
+var OfferStatusValues = [
+  "valid",
+  "callback_not_supported",
+  "callback_error",
+  "unverified"
+];
+var RouterOfferSchema = (parameters) => mempool.Offer.OfferSchema(parameters).extend({
+  consumed: v4.z.bigint({ coerce: true }).min(0n).max(viem.maxUint256),
+  status: v4.z.enum(OfferStatusValues),
+  metadata: v4.z.object({
+    issue: v4.z.string()
+  }).optional()
+});
+function from(input) {
+  try {
+    const parsedOffer = RouterOfferSchema({ omitHash: true }).parse(input);
+    const parsedHash = mempool.Offer.OfferHashSchema.parse(mempool.Offer.hash(parsedOffer));
+    return {
+      ...parsedOffer,
+      hash: parsedHash
+    };
+  } catch (error) {
+    throw new InvalidRouterOfferError(error);
+  }
+}
+function fromSnakeCase(input) {
+  return from(mempool.Format.fromSnakeCase(input));
+}
+function toSnakeCase(offer) {
+  return mempool.Format.toSnakeCase(offer);
+}
+function random() {
+  const baseOffer = mempool.Offer.random();
+  return from({
+    ...baseOffer,
+    status: "valid",
+    metadata: void 0,
+    consumed: 0n
+  });
+}
+var InvalidRouterOfferError = class extends mempool.Errors.BaseError {
+  constructor(error) {
+    super("Invalid router offer.", { cause: error });
+    __publicField(this, "name", "RouterOffer.InvalidRouterOfferError");
+  }
+};
+
+// src/utils/batch.ts
+function* batch(array, batchSize) {
+  for (let i = 0; i < array.length; i += batchSize) {
+    yield array.slice(i, i + batchSize);
+  }
+}
+
+// src/utils/cursor.ts
+function validateCursor(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}`
+    );
+  }
+  return true;
+}
+function encodeCursor(c) {
+  return Buffer.from(JSON.stringify(c)).toString("base64url");
+}
+function decodeCursor(token) {
+  if (!token) return null;
+  const decoded = JSON.parse(Buffer.from(token, "base64url").toString());
+  validateCursor(decoded);
+  return decoded;
+}
+
+// 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/core/apiSchema/requests.ts
+var MAX_LIMIT = 100;
+var DEFAULT_LIMIT = 20;
+var MAX_LLTV = 100;
+var MIN_LLTV = 0;
+var GetOffersQueryParams = v4.z.object({
+  // Core filtering parameters
+  creators: v4.z.string().regex(/^0x[a-fA-F0-9]{40}(,0x[a-fA-F0-9]{40})*$/, {
+    message: "Creators must be comma-separated Ethereum addresses"
+  }).transform((val) => val.split(",").map((addr) => addr.toLowerCase())).optional().meta({
+    description: "Filter by multiple creator addresses (comma-separated)",
+    example: "0x1234567890123456789012345678901234567890,0xabcdefabcdefabcdefabcdefabcdefabcdefabcd"
+  }),
+  side: v4.z.enum(["buy", "sell"]).optional().meta({
+    description: "Filter by offer type: buy offers or sell offers",
+    example: "buy"
+  }),
+  chains: v4.z.string().regex(/^\d+(,\d+)*$/, {
+    message: "Chains must be comma-separated chain IDs"
+  }).transform((val) => val.split(",").map(Number)).optional().meta({
+    description: "Filter by multiple blockchain networks (comma-separated chain IDs)",
+    example: "1,137,10"
+  }),
+  loan_tokens: v4.z.string().regex(/^0x[a-fA-F0-9]{40}(,0x[a-fA-F0-9]{40})*$/, {
+    message: "Loan assets must be comma-separated Ethereum addresses"
+  }).transform((val) => val.split(",").map((addr) => addr.toLowerCase())).optional().meta({
+    description: "Filter by multiple loan assets (comma-separated)",
+    example: "0x1234567890123456789012345678901234567890,0xabcdefabcdefabcdefabcdefabcdefabcdefabcd"
+  }),
+  status: v4.z.string().regex(/^[a-zA-Z_]+(,[a-zA-Z_]+)*$/, {
+    message: "Status must be comma-separated status values"
+  }).transform((val) => val.split(",")).refine((statuses) => statuses.every((status) => OfferStatusValues.includes(status)), {
+    message: `Invalid status value. Must be one of: ${OfferStatusValues.join(", ")}`
+  }).optional().meta({
+    description: `Filter by multiple statuses (comma-separated). Valid values: ${OfferStatusValues.join(", ")}. By default, only offers with 'valid' status are returned.`,
+    example: "valid,callback_error"
+  }),
+  callback_addresses: v4.z.string().regex(/^0x[a-fA-F0-9]{40}(,0x[a-fA-F0-9]{40})*$/, {
+    message: "Callback addresses must be comma-separated Ethereum addresses"
+  }).transform((val) => val.split(",").map((addr) => addr.toLowerCase())).optional().meta({
+    description: "Filter by multiple callback addresses (comma-separated)",
+    example: "0x1234567890123456789012345678901234567890,0xabcdefabcdefabcdefabcdefabcdefabcdefabcd"
+  }),
+  // Asset range
+  min_amount: v4.z.bigint({ coerce: true }).positive({
+    message: "Min amount must be a positive number"
+  }).optional().meta({
+    description: "Minimum amount of assets in the offer",
+    example: "1000"
+  }),
+  max_amount: v4.z.bigint({ coerce: true }).positive({
+    message: "Max amount must be a positive number"
+  }).optional().meta({
+    description: "Maximum amount of assets in the offer",
+    example: "10000"
+  }),
+  // Rate range
+  min_rate: v4.z.bigint({ coerce: true }).positive({
+    message: "Min rate must be a positive number"
+  }).optional().meta({
+    description: "Minimum rate per asset (in wei)",
+    example: "500000000000000000"
+  }),
+  max_rate: v4.z.bigint({ coerce: true }).positive({
+    message: "Max rate must be a positive number"
+  }).optional().meta({
+    description: "Maximum rate per asset (in wei)",
+    example: "1500000000000000000"
+  }),
+  // Time range
+  min_maturity: v4.z.bigint({ coerce: true }).min(0n).optional().transform((val) => val === void 0 ? void 0 : Number(val)).meta({
+    description: "Minimum maturity timestamp (Unix timestamp in seconds)",
+    example: "1700000000"
+  }),
+  max_maturity: v4.z.bigint({ coerce: true }).min(0n).optional().transform((val) => val === void 0 ? void 0 : Number(val)).meta({
+    description: "Maximum maturity timestamp (Unix timestamp in seconds)",
+    example: "1800000000"
+  }),
+  min_expiry: v4.z.bigint({ coerce: true }).min(0n).optional().transform((val) => val === void 0 ? void 0 : Number(val)).meta({
+    description: "Minimum expiry timestamp (Unix timestamp in seconds)",
+    example: "1700000000"
+  }),
+  max_expiry: v4.z.bigint({ coerce: true }).min(0n).optional().transform((val) => val === void 0 ? void 0 : Number(val)).meta({
+    description: "Maximum expiry timestamp (Unix timestamp in seconds)",
+    example: "1800000000"
+  }),
+  // Collateral filtering
+  collateral_assets: v4.z.string().regex(/^0x[a-fA-F0-9]{40}(,0x[a-fA-F0-9]{40})*$/, {
+    message: "Collateral assets must be comma-separated Ethereum addresses"
+  }).transform((val) => val.split(",").map((addr) => addr.toLowerCase())).optional().meta({
+    description: "Filter by multiple collateral assets (comma-separated)",
+    example: "0x1234567890123456789012345678901234567890,0xabcdefabcdefabcdefabcdefabcdefabcdefabcd"
+  }),
+  collateral_oracles: v4.z.string().regex(/^0x[a-fA-F0-9]{40}(,0x[a-fA-F0-9]{40})*$/, {
+    message: "Collateral oracles must be comma-separated Ethereum addresses"
+  }).transform((val) => val.split(",").map((addr) => addr.toLowerCase())).optional().meta({
+    description: "Filter by multiple rate oracles (comma-separated)",
+    example: "0x1234567890123456789012345678901234567890,0xabcdefabcdefabcdefabcdefabcdefabcdefabcd"
+  }),
+  collateral_tuple: v4.z.string().regex(
+    /^(0x[a-fA-F0-9]{40}(:0x[a-fA-F0-9]{40})?(:[0-9]+(\.[0-9]+)?)?)(#0x[a-fA-F0-9]{40}(:0x[a-fA-F0-9]{40})?(:[0-9]+(\.[0-9]+)?)?)*$/,
+    {
+      message: "Collateral tuple must be in format: asset:oracle:lltv#asset2:oracle2:lltv2. Oracle and lltv are optional. Asset must be 0x + 40 hex chars, oracle must be 0x + 40 hex chars, lltv must be a number (e.g., 80.5)."
+    }
+  ).transform((val) => {
+    return val.split("#").map((tuple) => {
+      const parts = tuple.split(":");
+      if (parts.length === 0 || !parts[0]) {
+        throw new v4.z.ZodError([
+          {
+            code: "custom",
+            message: "Asset address is required for each collateral tuple",
+            path: ["collateral_tuple"],
+            input: val
+          }
+        ]);
+      }
+      const asset = parts[0]?.toLowerCase();
+      const oracle = parts[1]?.toLowerCase();
+      const lltv = parts[2] ? parseFloat(parts[2]) : void 0;
+      if (lltv !== void 0 && (lltv < MIN_LLTV || lltv > MAX_LLTV)) {
+        throw new v4.z.ZodError([
+          {
+            code: "custom",
+            message: `LLTV must be between ${MIN_LLTV} and ${MAX_LLTV} (0-100%)`,
+            path: ["collateral_tuple"],
+            input: val
+          }
+        ]);
+      }
+      return {
+        asset,
+        oracle,
+        lltv
+      };
+    });
+  }).optional().meta({
+    description: "Filter by collateral combinations in format: asset:oracle:lltv#asset2:oracle2:lltv2. Oracle and lltv are optional. Use # to separate multiple combinations.",
+    example: "0x1234567890123456789012345678901234567890:0xabcdefabcdefabcdefabcdefabcdefabcdefabcd:8000#0x9876543210987654321098765432109876543210::8000"
+  }),
+  min_lltv: v4.z.string().regex(/^\d+(\.\d+)?$/, {
+    message: "Min LLTV must be a valid number"
+  }).transform((val) => parseFloat(val)).pipe(v4.z.number().min(0).max(100)).optional().meta({
+    description: "Minimum Loan-to-Value ratio (LLTV) for collateral (percentage as decimal, e.g., 80.5 = 80.5%)",
+    example: "80.5"
+  }),
+  max_lltv: v4.z.string().regex(/^\d+(\.\d+)?$/, {
+    message: "Max LLTV must be a valid number"
+  }).transform((val) => parseFloat(val)).pipe(v4.z.number().min(0).max(100)).optional().meta({
+    description: "Maximum Loan-to-Value ratio (LLTV) for collateral (percentage as decimal, e.g., 95.5 = 95.5%)",
+    example: "95.5"
+  }),
+  // Sorting parameters
+  sort_by: v4.z.enum(["rate", "maturity", "expiry", "amount"]).optional().meta({
+    description: "Field to sort results by",
+    example: "rate"
+  }),
+  sort_order: v4.z.enum(["asc", "desc"]).optional().default("desc").meta({
+    description: "Sort direction: asc (ascending) or desc (descending, default)",
+    example: "desc"
+  }),
+  // Pagination
+  cursor: v4.z.string().optional().refine(
+    (val) => {
+      if (!val) return true;
+      try {
+        const decoded = decodeCursor(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: v4.z.string().regex(/^[1-9]\d*$/, {
+    message: "Limit must be a positive integer"
+  }).transform((val) => Number.parseInt(val, 10)).pipe(
+    v4.z.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
+  })
+}).refine(
+  (data) => data.min_maturity === void 0 || data.max_maturity === void 0 || data.max_maturity >= data.min_maturity,
+  {
+    message: "max_maturity must be greater than or equal to min_maturity",
+    path: ["max_maturity"]
+  }
+).refine(
+  (data) => data.min_expiry === void 0 || data.max_expiry === void 0 || data.max_expiry >= data.min_expiry,
+  {
+    message: "max_expiry must be greater than or equal to min_expiry",
+    path: ["max_expiry"]
+  }
+).refine(
+  (data) => data.min_amount === void 0 || data.max_amount === void 0 || data.max_amount >= data.min_amount,
+  {
+    message: "max_amount must be greater than or equal to min_amount",
+    path: ["max_amount"]
+  }
+).refine(
+  (data) => data.min_rate === void 0 || data.max_rate === void 0 || data.max_rate >= data.min_rate,
+  {
+    message: "max_rate must be greater than or equal to min_rate",
+    path: ["max_rate"]
+  }
+).refine(
+  (data) => data.min_lltv === void 0 || data.max_lltv === void 0 || data.max_lltv >= data.min_lltv,
+  {
+    message: "max_lltv must be greater than or equal to min_lltv",
+    path: ["max_lltv"]
+  }
+);
+var MatchOffersQueryParams = v4.z.object({
+  // Required parameters
+  side: v4.z.enum(["buy", "sell"]).meta({
+    description: "The desired side of the match: 'buy' if you want to buy, 'sell' if you want to sell. If your intent is to sell, buy offers will be returned, and vice versa.",
+    example: "buy"
+  }),
+  chain_id: v4.z.string().regex(/^\d+$/, {
+    message: "Chain ID must be a positive integer"
+  }).transform((val) => Number.parseInt(val, 10)).pipe(v4.z.number().positive()).meta({
+    description: "The blockchain network chain ID",
+    example: "1"
+  }),
+  // Optional parameters
+  rate: v4.z.bigint({ coerce: true }).positive({
+    message: "Rate must be a positive number"
+  }).optional().meta({
+    description: "Rate per asset (in wei) for matching offers",
+    example: "1000000000000000000"
+  }),
+  // Collateral filtering
+  collaterals: v4.z.string().regex(
+    /^(0x[a-fA-F0-9]{40}:0x[a-fA-F0-9]{40}:\d+)(#0x[a-fA-F0-9]{40}:0x[a-fA-F0-9]{40}:\d+)*$/,
+    {
+      message: "Collaterals must be in format: asset:oracle:lltv#asset2:oracle2:lltv2. All fields are required for each collateral."
+    }
+  ).transform((val) => {
+    return val.split("#").map((collateral) => {
+      const parts = collateral.split(":");
+      if (parts.length !== 3) {
+        throw new v4.z.ZodError([
+          {
+            code: "custom",
+            message: "Each collateral must have exactly 3 parts: asset:oracle:lltv",
+            path: ["collaterals"],
+            input: val
+          }
+        ]);
+      }
+      const [asset, oracle, lltvStr] = parts;
+      if (!asset || !oracle || !lltvStr) {
+        throw new v4.z.ZodError([
+          {
+            code: "custom",
+            message: "Asset, oracle, and lltv are all required for each collateral",
+            path: ["collaterals"],
+            input: val
+          }
+        ]);
+      }
+      const lltv = BigInt(lltvStr);
+      if (lltv <= 0n) {
+        throw new v4.z.ZodError([
+          {
+            code: "custom",
+            message: "LLTV must be a positive number",
+            path: ["collaterals"],
+            input: val
+          }
+        ]);
+      }
+      return {
+        asset: asset.toLowerCase(),
+        oracle: oracle.toLowerCase(),
+        lltv
+      };
+    });
+  }).optional().meta({
+    description: "Collateral requirements in format: asset:oracle:lltv#asset2:oracle2:lltv2. Use # to separate multiple collaterals.",
+    example: "0x1234567890123456789012345678901234567890:0xabcdefabcdefabcdefabcdefabcdefabcdefabcd:800000000000000000#0x9876543210987654321098765432109876543210:0xfedcbafedcbafedcbafedcbafedcbafedcbafedc:900000000000000000"
+  }),
+  // Maturity filtering
+  maturity: v4.z.bigint({ coerce: true }).min(0n).optional().transform((val) => val === void 0 ? void 0 : Number(val)).meta({
+    description: "Exact maturity timestamp (Unix timestamp in seconds)",
+    example: "1700000000"
+  }),
+  min_maturity: v4.z.bigint({ coerce: true }).min(0n).optional().transform((val) => val === void 0 ? void 0 : Number(val)).meta({
+    description: "Minimum maturity timestamp (Unix timestamp in seconds, inclusive)",
+    example: "1700000000"
+  }),
+  max_maturity: v4.z.bigint({ coerce: true }).min(0n).optional().transform((val) => val === void 0 ? void 0 : Number(val)).meta({
+    description: "Maximum maturity timestamp (Unix timestamp in seconds, inclusive)",
+    example: "1800000000"
+  }),
+  // Asset and creator filtering
+  loan_token: v4.z.string().regex(/^0x[a-fA-F0-9]{40}$/, {
+    message: "Loan asset must be a valid Ethereum address"
+  }).transform((val) => val.toLowerCase()).optional().meta({
+    description: "The loan asset address to match against",
+    example: "0x1234567890123456789012345678901234567890"
+  }),
+  creator: v4.z.string().regex(/^0x[a-fA-F0-9]{40}$/, {
+    message: "Creator must be a valid Ethereum address"
+  }).transform((val) => val.toLowerCase()).optional().meta({
+    description: "Filter by a specific offer creator address",
+    example: "0x1234567890123456789012345678901234567890"
+  }),
+  // Status filtering
+  status: v4.z.string().regex(/^[a-zA-Z_]+(,[a-zA-Z_]+)*$/, {
+    message: "Status must be comma-separated status values"
+  }).transform((val) => val.split(",")).refine((statuses) => statuses.every((status) => OfferStatusValues.includes(status)), {
+    message: `Invalid status value. Must be one of: ${OfferStatusValues.join(", ")}`
+  }).optional().meta({
+    description: `Filter by multiple statuses (comma-separated). Valid values: ${OfferStatusValues.join(", ")}. By default, only offers with 'valid' status are returned.`,
+    example: "valid,callback_error"
+  }),
+  // Pagination
+  cursor: v4.z.string().optional().refine(
+    (val) => {
+      if (!val) return true;
+      try {
+        const decoded = decodeCursor(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: v4.z.string().regex(/^[1-9]\d*$/, {
+    message: "Limit must be a positive integer"
+  }).transform((val) => Number.parseInt(val, 10)).pipe(
+    v4.z.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
+  })
+}).refine(
+  (data) => data.min_maturity === void 0 || data.max_maturity === void 0 || data.max_maturity >= data.min_maturity,
+  {
+    message: "max_maturity must be greater than or equal to min_maturity",
+    path: ["max_maturity"]
+  }
+);
+var schemas = {
+  get_offers: GetOffersQueryParams,
+  match_offers: MatchOffersQueryParams
+};
+function safeParse(action, query) {
+  return schemas[action].safeParse(query);
+}
+
+// src/core/apiSchema/openapi.ts
+var successResponseSchema = v4.z.object({
+  status: v4.z.literal("success"),
+  cursor: v4.z.string().nullable(),
+  data: v4.z.array(v4.z.any()),
+  meta: v4.z.object({
+    timestamp: v4.z.string()
+  })
+});
+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()
+  })
+});
+var paths = {
+  "/v1/offers": {
+    get: {
+      summary: "Get offers",
+      description: "Get all offers with optional filtering and pagination",
+      tags: ["Offers"],
+      requestParams: {
+        query: GetOffersQueryParams
+      },
+      responses: {
+        200: {
+          description: "Success",
+          content: {
+            "application/json": {
+              schema: successResponseSchema
+            }
+          }
+        },
+        400: {
+          description: "Bad Request",
+          content: {
+            "application/json": {
+              schema: errorResponseSchema
+            }
+          }
+        }
+      }
+    }
+  },
+  "/v1/match-offers": {
+    get: {
+      summary: "Match offers",
+      description: "Find offers that match specific criteria",
+      tags: ["Offers"],
+      requestParams: {
+        query: MatchOffersQueryParams
+      },
+      responses: {
+        200: {
+          description: "Success",
+          content: {
+            "application/json": {
+              schema: successResponseSchema
+            }
+          }
+        },
+        400: {
+          description: "Bad Request",
+          content: {
+            "application/json": {
+              schema: errorResponseSchema
+            }
+          }
+        }
+      }
+    }
+  }
+};
+zodOpenapi.createDocument({
+  openapi: "3.1.0",
+  info: {
+    title: "Router API",
+    version: "1.0.0",
+    description: "API for the Morpho Router"
+  },
+  tags: [
+    {
+      name: "Offers"
+    }
+  ],
+  servers: [
+    {
+      url: "https://router.morpho.dev",
+      description: "Production server"
+    },
+    {
+      url: "http://localhost:8081",
+      description: "Local development server"
+    }
+  ],
+  paths
+});
+
+// src/core/Client.ts
 function connect(opts) {
   const u = new URL(opts?.url || "https://router.morpho.dev");
   if (u.protocol !== "http:" && u.protocol !== "https:") {
@@ -181,14 +823,7 @@ async function get(config, parameters) {
   const { cursor: returnedCursor, data: offers } = await getApi(config, url);
   return {
     cursor: returnedCursor,
-    offers: offers.map((offer) => {
-      const baseOffer = mempool.Offer.fromSnakeCase(offer);
-      return {
-        ...baseOffer,
-        status: offer.status,
-        metadata: offer.metadata
-      };
-    })
+    offers: offers.map(fromSnakeCase)
   };
 }
 async function match(config, parameters) {
@@ -229,24 +864,29 @@ async function match(config, parameters) {
   const { cursor: returnedCursor, data: offers } = await getApi(config, url);
   return {
     cursor: returnedCursor,
-    offers: offers.map((offer) => {
-      const baseOffer = mempool.Offer.fromSnakeCase(offer);
-      return {
-        ...baseOffer,
-        status: offer.status,
-        metadata: offer.metadata
-      };
-    })
+    offers: offers.map(fromSnakeCase)
   };
 }
 async function getApi(config, url) {
-  if (url.searchParams.get("limit") && Number(url.searchParams.get("limit")) > MAX_BATCH_SIZE) {
-    throw new HttpGetOffersFailedError(
-      `The maximum number of offers that can be returned is ${MAX_BATCH_SIZE}.`,
-      {
-        details: `The limit is set to ${url.searchParams.get("limit")}. Maximum is ${MAX_BATCH_SIZE}.`
-      }
-    );
+  const pathname = url.pathname;
+  let action;
+  switch (true) {
+    case pathname.includes("/v1/offers"):
+      action = "get_offers";
+      break;
+    case pathname.includes("/v1/match-offers"):
+      action = "match_offers";
+      break;
+    default:
+      throw new HttpGetOffersFailedError("Unknown endpoint", {
+        details: `Unsupported path: ${pathname}`
+      });
+  }
+  const schemaParseResult = safeParse(action, Object.fromEntries(url.searchParams));
+  if (!schemaParseResult.success) {
+    throw new HttpGetOffersFailedError(`Invalid URL parameters`, {
+      details: schemaParseResult.error.issues[0]?.message
+    });
   }
   const response = await fetch(url.toString(), {
     method: "GET",
@@ -329,48 +969,6 @@ function buildId(event) {
   }
 }
 
-// src/RouterOffer.ts
-var RouterOffer_exports = {};
-__export(RouterOffer_exports, {
-  OfferStatusValues: () => OfferStatusValues
-});
-var OfferStatusValues = [
-  "valid",
-  "callback_not_supported",
-  "callback_error",
-  "unverified"
-];
-
-// src/utils/batch.ts
-function* batch(array, batchSize) {
-  for (let i = 0; i < array.length; i += batchSize) {
-    yield array.slice(i, i + batchSize);
-  }
-}
-
-// 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/Validation.ts
 var Validation_exports = {};
 __export(Validation_exports, {
@@ -585,13 +1183,16 @@ function morpho(parameters) {
 }
 
 exports.Chain = Chain_exports;
-exports.Router = core_exports;
+exports.Router = Client_exports;
 exports.RouterEvent = RouterEvent_exports;
 exports.RouterOffer = RouterOffer_exports;
 exports.Validation = Validation_exports;
 exports.ValidationRule = ValidationRule_exports;
 exports.batch = batch;
+exports.decodeCursor = decodeCursor;
+exports.encodeCursor = encodeCursor;
 exports.poll = poll;
+exports.validateCursor = validateCursor;
 exports.wait = wait;
 Object.keys(mempool).forEach(function (k) {
   if (k !== 'default' && !Object.prototype.hasOwnProperty.call(exports, k)) Object.defineProperty(exports, k, {