@morpho-dev/router 0.1.10 → 0.1.12

package/dist/index.browser.js

@@ -2,9 +2,9 @@
 
 var mempool = require('@morpho-dev/mempool');
 var viem = require('viem');
-var jsBase64 = require('js-base64');
 var v4 = require('zod/v4');
 var zodOpenapi = require('zod-openapi');
+var jsBase64 = require('js-base64');
 
 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;
@@ -14,108 +14,104 @@ var __export = (target, all) => {
 };
 var __publicField = (obj, key, value) => __defNormalProp(obj, key + "" , value);
 
-// src/core/Callback.ts
-var Callback_exports = {};
-__export(Callback_exports, {
-  CallbackType: () => CallbackType,
-  WhitelistedCallbackAddresses: () => WhitelistedCallbackAddresses,
-  buildLiquidity: () => buildLiquidity,
-  decode: () => decode,
-  encode: () => encode,
-  getCallbackIdForOffer: () => getCallbackIdForOffer
+// src/api/Client.ts
+var Client_exports = {};
+__export(Client_exports, {
+  HttpForbiddenError: () => HttpForbiddenError,
+  HttpGetOffersFailedError: () => HttpGetOffersFailedError,
+  HttpRateLimitError: () => HttpRateLimitError,
+  HttpUnauthorizedError: () => HttpUnauthorizedError,
+  InvalidUrlError: () => InvalidUrlError,
+  connect: () => connect,
+  get: () => get,
+  match: () => match
 });
-var CallbackType = /* @__PURE__ */ ((CallbackType2) => {
-  CallbackType2["BuyWithEmptyCallback"] = "buy_with_empty_callback";
-  CallbackType2["SellWithdrawFromWallet"] = "sell_withdraw_from_wallet";
-  return CallbackType2;
-})(CallbackType || {});
-var WhitelistedCallbackAddresses = {
-  ["buy_with_empty_callback" /* BuyWithEmptyCallback */]: [],
-  ["sell_withdraw_from_wallet" /* SellWithdrawFromWallet */]: [
-    "0x1111111111111111111111111111111111111111",
-    "0x2222222222222222222222222222222222222222"
-    // @TODO: update once deployed and add mapping per chain if needed
-  ]
+
+// src/core/RouterOffer.ts
+var RouterOffer_exports = {};
+__export(RouterOffer_exports, {
+  InvalidRouterOfferError: () => InvalidRouterOfferError,
+  OfferStatusValues: () => OfferStatusValues,
+  RouterOfferSchema: () => RouterOfferSchema,
+  consumedEvent: () => consumedEvent,
+  from: () => from,
+  fromConsumedLog: () => fromConsumedLog,
+  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()
+});
+var consumedEvent = {
+  type: "event",
+  name: "Consumed",
+  inputs: [
+    { name: "user", type: "address", indexed: true, internalType: "address" },
+    { name: "nonce", type: "uint256", indexed: true, internalType: "uint256" },
+    { name: "amount", type: "uint256", indexed: false, internalType: "uint256" }
+  ],
+  anonymous: false
 };
-function buildLiquidity(parameters) {
-  const { type, user, contract, chainId, amount, index = 0, updatedAt = /* @__PURE__ */ new Date() } = parameters;
-  if (type !== "buy_with_empty_callback" /* BuyWithEmptyCallback */)
-    throw new Error(`CallbackType not implemented: ${type}`);
-  const amountStr = amount.toString();
-  const id = `${user}-${chainId.toString()}-${type}-${contract}`.toLowerCase();
-  return {
-    userPosition: {
-      id,
-      availableLiquidityQueueId: id,
-      user: user.toLowerCase(),
-      chainId,
-      amount: amountStr,
-      updatedAt
-    },
-    queues: [
-      {
-        queue: {
-          queueId: id,
-          availableLiquidityPoolId: id,
-          index,
-          updatedAt
-        },
-        pool: {
-          id,
-          amount: amountStr,
-          updatedAt
-        }
-      }
-    ]
-  };
-}
-function getCallbackIdForOffer(offer) {
-  if (offer.buy && offer.callback.data === "0x") {
-    const type = "buy_with_empty_callback" /* BuyWithEmptyCallback */;
-    const user = offer.offering;
-    const loanToken = offer.loanToken;
-    return `${user}-${offer.chainId.toString()}-${type}-${loanToken}`.toLowerCase();
-  }
-  return null;
-}
-function decodeSellWithdrawFromWalletData(data) {
-  if (!data || data === "0x") throw new Error("Empty callback data");
+function from(input) {
   try {
-    const [collaterals, amounts] = viem.decodeAbiParameters(
-      [{ type: "address[]" }, { type: "uint256[]" }],
-      data
-    );
-    if (collaterals.length !== amounts.length) {
-      throw new Error("Mismatched array lengths");
-    }
-    return collaterals.map((c, i) => ({ collateral: c, amount: amounts[i] }));
-  } catch (_) {
-    throw new Error("Invalid SellWithdrawFromWallet callback data");
+    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 decode(parameters) {
-  const { type, data } = parameters;
-  if (type === "sell_withdraw_from_wallet" /* SellWithdrawFromWallet */) {
-    return decodeSellWithdrawFromWalletData(data);
-  }
-  throw new Error(`CallbackType not implemented: ${type}`);
+function fromSnakeCase(input) {
+  return from(mempool.Format.fromSnakeCase(input));
 }
-function encode(parameters) {
-  const { type, data } = parameters;
-  if (type === "sell_withdraw_from_wallet" /* SellWithdrawFromWallet */) {
-    return viem.encodeAbiParameters(
-      [{ type: "address[]" }, { type: "uint256[]" }],
-      [data.collaterals, data.amounts]
-    );
-  }
-  throw new Error(`CallbackType not implemented: ${type}`);
+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
+  });
 }
+function fromConsumedLog(parameters) {
+  const { blockNumber, logIndex, chainId, transactionHash, user, nonce, amount } = parameters;
+  return {
+    id: `${blockNumber.toString()}-${logIndex.toString()}-${chainId}-${transactionHash}`,
+    chainId: BigInt(chainId),
+    offering: user,
+    nonce,
+    amount
+  };
+}
+var InvalidRouterOfferError = class extends mempool.Errors.BaseError {
+  constructor(error) {
+    super("Invalid router offer.", { cause: error });
+    __publicField(this, "name", "RouterOffer.InvalidRouterOfferError");
+  }
+};
 
 // src/core/Cursor.ts
 var Cursor_exports = {};
 __export(Cursor_exports, {
-  decode: () => decode2,
-  encode: () => encode2,
+  decode: () => decode,
+  encode: () => encode,
   validate: () => validate
 });
 function validate(cursor) {
@@ -187,242 +183,17 @@ function validate(cursor) {
   }
   return true;
 }
-function encode2(c) {
+function encode(c) {
   return jsBase64.Base64.encodeURL(JSON.stringify(c));
 }
-function decode2(token) {
+function decode(token) {
   if (!token) return null;
   const decoded = JSON.parse(jsBase64.Base64.decode(token));
   validate(decoded);
   return decoded;
 }
 
-// src/core/Liquidity.ts
-var Liquidity_exports = {};
-__export(Liquidity_exports, {
-  fetch: () => fetch2,
-  fetchBalancesAndAllowances: () => fetchBalancesAndAllowances,
-  serialize: () => serialize
-});
-async function fetchBalancesAndAllowances(parameters) {
-  const { client, spender, pairs, options } = parameters;
-  if (pairs.length === 0) return /* @__PURE__ */ new Map();
-  const batchSize = Math.max(1, options?.batchSize ?? 5e3);
-  const retryAttempts = Math.max(1, options?.retryAttempts ?? 3);
-  const retryDelayMs = Math.max(0, options?.retryDelayMs ?? 50);
-  const blockNumber = options?.blockNumber ? BigInt(options.blockNumber) : void 0;
-  const out = /* @__PURE__ */ new Map();
-  for (const pairsBatch of mempool.Utils.batch(pairs, batchSize)) {
-    const balanceContracts = [];
-    const allowanceContracts = [];
-    for (const { user, token } of pairsBatch) {
-      balanceContracts.push({
-        address: token,
-        abi: viem.erc20Abi,
-        functionName: "balanceOf",
-        args: [user]
-      });
-      allowanceContracts.push({
-        address: token,
-        abi: viem.erc20Abi,
-        functionName: "allowance",
-        args: [user, spender]
-      });
-    }
-    const [balances, allowances] = await Promise.all([
-      mempool.Utils.retry(
-        () => client.multicall({
-          allowFailure: false,
-          contracts: balanceContracts,
-          ...blockNumber ? { blockNumber } : {}
-        }),
-        retryAttempts,
-        retryDelayMs
-      ),
-      mempool.Utils.retry(
-        () => client.multicall({
-          allowFailure: false,
-          contracts: allowanceContracts,
-          ...blockNumber ? { blockNumber } : {}
-        }),
-        retryAttempts,
-        retryDelayMs
-      )
-    ]);
-    for (let i = 0; i < pairsBatch.length; i++) {
-      const { user, token } = pairsBatch[i];
-      const balance = balances[i];
-      const allowance = allowances[i];
-      let perUser = out.get(user);
-      if (!perUser) {
-        perUser = /* @__PURE__ */ new Map();
-        out.set(user, perUser);
-      }
-      perUser.set(token, { balance, allowance });
-    }
-  }
-  return out;
-}
-async function fetch2(parameters) {
-  const { client, chainId, spender, type, pairs, options } = parameters;
-  if (type !== "buy_with_empty_callback" /* BuyWithEmptyCallback */)
-    throw new Error(`CallbackType not implemented: ${type}`);
-  const map = await fetchBalancesAndAllowances({
-    client,
-    spender,
-    pairs: pairs.map(({ user, contract }) => ({ user, token: contract })),
-    options
-  });
-  const out = [];
-  for (const [user, perContract] of map) {
-    for (const [contract, { balance, allowance }] of perContract) {
-      const amount = balance < allowance ? balance : allowance;
-      out.push(
-        buildLiquidity({
-          type,
-          user,
-          contract,
-          chainId,
-          amount: amount.toString(),
-          index: 0
-        })
-      );
-    }
-  }
-  return out;
-}
-function serialize(liquidity) {
-  const normalized = {
-    userPosition: {
-      id: liquidity.userPosition.id,
-      availableLiquidityQueueId: liquidity.userPosition.availableLiquidityQueueId,
-      user: liquidity.userPosition.user,
-      chainId: String(liquidity.userPosition.chainId),
-      amount: String(liquidity.userPosition.amount)
-    },
-    queues: liquidity.queues.map((queueWithPool) => ({
-      queue: {
-        queueId: queueWithPool.queue.queueId,
-        availableLiquidityPoolId: queueWithPool.queue.availableLiquidityPoolId,
-        index: queueWithPool.queue.index
-      },
-      pool: {
-        id: queueWithPool.pool.id,
-        amount: String(queueWithPool.pool.amount)
-      }
-    })).sort(
-      (left, right) => {
-        const leftQueueId = left.queue.queueId || "";
-        const rightQueueId = right.queue.queueId || "";
-        if (leftQueueId < rightQueueId) return -1;
-        if (leftQueueId > rightQueueId) return 1;
-        const leftPoolId = left.pool.id;
-        const rightPoolId = right.pool.id;
-        if (leftPoolId < rightPoolId) return -1;
-        if (leftPoolId > rightPoolId) return 1;
-        const leftIndex = left.queue.index;
-        const rightIndex = right.queue.index;
-        if (leftIndex < rightIndex) return -1;
-        if (leftIndex > rightIndex) return 1;
-        return 0;
-      }
-    )
-  };
-  return JSON.stringify(normalized);
-}
-
-// src/core/RouterOffer.ts
-var RouterOffer_exports = {};
-__export(RouterOffer_exports, {
-  InvalidRouterOfferError: () => InvalidRouterOfferError,
-  OfferStatusValues: () => OfferStatusValues,
-  RouterOfferSchema: () => RouterOfferSchema,
-  consumedEvent: () => consumedEvent,
-  from: () => from,
-  fromConsumedLog: () => fromConsumedLog,
-  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()
-});
-var consumedEvent = {
-  type: "event",
-  name: "Consumed",
-  inputs: [
-    { name: "user", type: "address", indexed: true, internalType: "address" },
-    { name: "nonce", type: "uint256", indexed: true, internalType: "uint256" },
-    { name: "amount", type: "uint256", indexed: false, internalType: "uint256" }
-  ],
-  anonymous: false
-};
-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
-  });
-}
-function fromConsumedLog(parameters) {
-  const { blockNumber, logIndex, chainId, transactionHash, user, nonce, amount } = parameters;
-  return {
-    id: `${blockNumber.toString()}-${logIndex.toString()}-${chainId}-${transactionHash}`,
-    chainId: BigInt(chainId),
-    offering: user,
-    nonce,
-    amount
-  };
-}
-var InvalidRouterOfferError = class extends mempool.Errors.BaseError {
-  constructor(error) {
-    super("Invalid router offer.", { cause: error });
-    __publicField(this, "name", "RouterOffer.InvalidRouterOfferError");
-  }
-};
-
-// src/core/router/Client.ts
-var Client_exports = {};
-__export(Client_exports, {
-  HttpForbiddenError: () => HttpForbiddenError,
-  HttpGetOffersFailedError: () => HttpGetOffersFailedError,
-  HttpRateLimitError: () => HttpRateLimitError,
-  HttpUnauthorizedError: () => HttpUnauthorizedError,
-  InvalidUrlError: () => InvalidUrlError,
-  connect: () => connect,
-  get: () => get,
-  match: () => match
-});
+// src/api/Schema/requests.ts
 var MAX_LIMIT = 100;
 var DEFAULT_LIMIT = 20;
 var MAX_LLTV = 100;
@@ -599,7 +370,7 @@ var GetOffersQueryParams = v4.z.object({
     (val) => {
       if (!val) return true;
       try {
-        const decoded = decode2(val);
+        const decoded = decode(val);
         return decoded !== null;
       } catch (_error) {
         return false;
@@ -771,7 +542,7 @@ var MatchOffersQueryParams = v4.z.object({
     (val) => {
       if (!val) return true;
       try {
-        const decoded = decode2(val);
+        const decoded = decode(val);
         return decoded !== null;
       } catch (_error) {
         return false;
@@ -811,7 +582,7 @@ function safeParse(action, query, error) {
   });
 }
 
-// src/core/apiSchema/openapi.ts
+// src/api/Schema/openapi.ts
 var successResponseSchema = v4.z.object({
   status: v4.z.literal("success"),
   cursor: v4.z.string().nullable(),
@@ -914,7 +685,7 @@ zodOpenapi.createDocument({
   paths
 });
 
-// src/core/apiSchema/utils.ts
+// src/api/Schema/utils.ts
 function toResponse(routerOffer) {
   const { consumed, status, metadata, ...offer } = routerOffer;
   return {
@@ -934,7 +705,7 @@ function fromResponse(offerResponse) {
   };
 }
 
-// src/core/router/Client.ts
+// src/api/Client.ts
 function connect(opts) {
   const u = new URL(opts?.url || "https://router.morpho.dev");
   if (u.protocol !== "http:" && u.protocol !== "https:") {
@@ -1034,135 +805,720 @@ async function get(config, parameters) {
   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(mempool.Format.fromSnakeCase).map(fromResponse);
-  return {
-    cursor: returnedCursor,
-    offers: routerOffers.map(from).map(toResponse)
-  };
+  const { cursor: returnedCursor, data: offers } = await getApi(config, url);
+  const routerOffers = offers.map(mempool.Format.fromSnakeCase).map(fromResponse);
+  return {
+    cursor: returnedCursor,
+    offers: routerOffers.map(from).map(toResponse)
+  };
+}
+async function match(config, parameters) {
+  const url = new URL(`${config.url.toString()}v1/offers/match`);
+  url.searchParams.set("side", parameters.side);
+  url.searchParams.set("chain_id", parameters.chainId.toString());
+  if (parameters.rate !== void 0) {
+    url.searchParams.set("rate", parameters.rate.toString());
+  }
+  if (parameters.collaterals?.length) {
+    const collateralsStr = parameters.collaterals.map(({ asset, oracle, lltv }) => `${asset}:${oracle}:${viem.formatUnits(lltv, 16)}`).join("#");
+    url.searchParams.set("collaterals", collateralsStr);
+  }
+  if (parameters.maturity !== void 0) {
+    url.searchParams.set("maturity", parameters.maturity.toString());
+  }
+  if (parameters.minMaturity !== void 0) {
+    url.searchParams.set("min_maturity", parameters.minMaturity.toString());
+  }
+  if (parameters.maxMaturity !== void 0) {
+    url.searchParams.set("max_maturity", parameters.maxMaturity.toString());
+  }
+  if (parameters.loanToken) {
+    url.searchParams.set("loan_token", parameters.loanToken);
+  }
+  if (parameters.creator) {
+    url.searchParams.set("creator", parameters.creator);
+  }
+  if (parameters.status?.length) {
+    url.searchParams.set("status", parameters.status.join(","));
+  }
+  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(mempool.Format.fromSnakeCase).map(fromResponse);
+  return {
+    cursor: returnedCursor,
+    offers: routerOffers.map(from).map(toResponse)
+  };
+}
+async function getApi(config, url) {
+  const pathname = url.pathname;
+  let action;
+  switch (true) {
+    case pathname.includes("/v1/offers/match"):
+      action = "match_offers";
+      break;
+    case pathname.includes("/v1/offers"):
+      action = "get_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",
+    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 HttpGetOffersFailedError(`GET request returned ${response.status}`, {
+      details: await response.text()
+    });
+  }
+  return response.json();
+}
+var InvalidUrlError = class extends mempool.Errors.BaseError {
+  constructor(url) {
+    super(`URL "${url}" is not http/https.`);
+    __publicField(this, "name", "Router.InvalidUrlError");
+  }
+};
+var HttpUnauthorizedError = class extends mempool.Errors.BaseError {
+  constructor() {
+    super("Unauthorized.", {
+      metaMessages: ["Ensure that an API key is provided."]
+    });
+    __publicField(this, "name", "Router.HttpUnauthorizedError");
+  }
+};
+var HttpForbiddenError = class extends mempool.Errors.BaseError {
+  constructor() {
+    super("Forbidden.", {
+      metaMessages: ["Ensure that the API key is valid."]
+    });
+    __publicField(this, "name", "Router.HttpForbiddenError");
+  }
+};
+var HttpRateLimitError = class extends mempool.Errors.BaseError {
+  constructor() {
+    super("Rate limit exceeded.", {
+      metaMessages: [
+        "The number of allowed requests has been exceeded. You must wait for the rate limit to reset."
+      ]
+    });
+    __publicField(this, "name", "Router.HttpRateLimitError");
+  }
+};
+var HttpGetOffersFailedError = class extends mempool.Errors.BaseError {
+  constructor(message, { details } = {}) {
+    super(message, {
+      metaMessages: [details]
+    });
+    __publicField(this, "name", "Router.HttpGetOffersFailedError");
+  }
+};
+
+// src/core/Callback.ts
+var Callback_exports = {};
+__export(Callback_exports, {
+  CallbackType: () => CallbackType,
+  WhitelistedCallbackAddresses: () => WhitelistedCallbackAddresses,
+  buildLiquidity: () => buildLiquidity,
+  decode: () => decode2,
+  encode: () => encode2,
+  getCallbackIdForOffer: () => getCallbackIdForOffer
+});
+var CallbackType = /* @__PURE__ */ ((CallbackType2) => {
+  CallbackType2["BuyWithEmptyCallback"] = "buy_with_empty_callback";
+  CallbackType2["SellERC20Callback"] = "sell_erc20_callback";
+  return CallbackType2;
+})(CallbackType || {});
+var WhitelistedCallbackAddresses = {
+  ["buy_with_empty_callback" /* BuyWithEmptyCallback */]: [],
+  ["sell_erc20_callback" /* SellERC20Callback */]: [
+    "0x1111111111111111111111111111111111111111",
+    "0x2222222222222222222222222222222222222222"
+    // @TODO: update once deployed and add mapping per chain if needed
+  ].map((address) => address.toLowerCase())
+};
+function buildLiquidity(parameters) {
+  switch (parameters.type) {
+    case "buy_with_empty_callback" /* BuyWithEmptyCallback */: {
+      const { user, loanToken, chainId, amount, index = 0, updatedAt = /* @__PURE__ */ new Date() } = parameters;
+      const amountStr = amount.toString();
+      const id = `${user}-${chainId.toString()}-${parameters.type}-${loanToken}`.toLowerCase();
+      const poolId = `${user}-${chainId.toString()}-${loanToken}`.toLowerCase();
+      return {
+        userPosition: {
+          id,
+          availableLiquidityQueueId: id,
+          user: user.toLowerCase(),
+          chainId,
+          amount: amountStr,
+          updatedAt
+        },
+        queues: [
+          {
+            queue: {
+              queueId: id,
+              availableLiquidityPoolId: poolId,
+              index,
+              callbackAmount: "0",
+              updatedAt
+            },
+            pool: {
+              id: poolId,
+              amount: amountStr,
+              updatedAt
+            }
+          }
+        ]
+      };
+    }
+    case "sell_erc20_callback" /* SellERC20Callback */: {
+      const {
+        user,
+        termId,
+        offerHash,
+        chainId,
+        amount,
+        collaterals,
+        index = 0,
+        updatedAt = /* @__PURE__ */ new Date()
+      } = parameters;
+      const amountStr = amount.toString();
+      const id = `${user}-${chainId.toString()}-${parameters.type}-${termId}-${offerHash}`.toLowerCase();
+      return {
+        userPosition: {
+          id,
+          availableLiquidityQueueId: id,
+          user: user.toLowerCase(),
+          chainId,
+          amount: amountStr,
+          updatedAt
+        },
+        queues: collaterals.map((collateral) => {
+          const poolId = `${user}-${chainId.toString()}-${collateral.collateralAddress}`.toLowerCase();
+          return {
+            queue: {
+              queueId: id,
+              availableLiquidityPoolId: poolId,
+              index,
+              callbackAmount: collateral.callbackAmount.toString(),
+              updatedAt
+            },
+            pool: {
+              id: poolId,
+              amount: collateral.balance.toString(),
+              updatedAt
+            }
+          };
+        })
+      };
+    }
+    default: {
+      throw new Error(`CallbackType not implemented`);
+    }
+  }
+}
+function getCallbackIdForOffer(offer) {
+  if (offer.buy && offer.callback.data === "0x") {
+    return `${offer.offering}-${offer.chainId.toString()}-${"buy_with_empty_callback" /* BuyWithEmptyCallback */}-${offer.loanToken}`.toLowerCase();
+  }
+  if (!offer.buy && offer.callback.data !== "0x" && WhitelistedCallbackAddresses["sell_erc20_callback" /* SellERC20Callback */].includes(
+    offer.callback.address.toLowerCase()
+  )) {
+    return `${offer.offering}-${offer.chainId.toString()}-${"sell_erc20_callback" /* SellERC20Callback */}-${mempool.Offer.termId(offer)}-${offer.hash}`.toLowerCase();
+  }
+  return null;
+}
+function decodeSellERC20CallbackData(data) {
+  if (!data || data === "0x") throw new Error("Empty callback data");
+  try {
+    const [collaterals, amounts] = viem.decodeAbiParameters(
+      [{ type: "address[]" }, { type: "uint256[]" }],
+      data
+    );
+    if (collaterals.length !== amounts.length) {
+      throw new Error("Mismatched array lengths");
+    }
+    return collaterals.map((c, i) => ({ collateral: c, amount: amounts[i] }));
+  } catch (_) {
+    throw new Error("Invalid SellERC20Callback callback data");
+  }
+}
+function decode2(parameters) {
+  const { type, data } = parameters;
+  if (type === "sell_erc20_callback" /* SellERC20Callback */) {
+    return decodeSellERC20CallbackData(data);
+  }
+  throw new Error(`CallbackType not implemented: ${type}`);
+}
+function encode2(parameters) {
+  const { type, data } = parameters;
+  if (type === "sell_erc20_callback" /* SellERC20Callback */) {
+    return viem.encodeAbiParameters(
+      [{ type: "address[]" }, { type: "uint256[]" }],
+      [data.collaterals, data.amounts]
+    );
+  }
+  throw new Error(`CallbackType not implemented: ${type}`);
+}
+
+// src/core/Liquidity.ts
+var Liquidity_exports = {};
+__export(Liquidity_exports, {
+  create: () => create,
+  serialize: () => serialize
+});
+
+// src/core/Abi.ts
+var Oracle = [
+  {
+    type: "function",
+    name: "price",
+    inputs: [],
+    outputs: [{ name: "", type: "uint256" }],
+    stateMutability: "view"
+  }
+];
+var Morpho = [
+  {
+    type: "function",
+    name: "collateralOf",
+    inputs: [
+      {
+        name: "",
+        type: "address",
+        internalType: "address"
+      },
+      {
+        name: "",
+        type: "bytes32",
+        internalType: "bytes32"
+      },
+      {
+        name: "",
+        type: "address",
+        internalType: "address"
+      }
+    ],
+    outputs: [
+      {
+        name: "",
+        type: "uint256",
+        internalType: "uint256"
+      }
+    ],
+    stateMutability: "view"
+  },
+  {
+    type: "function",
+    name: "debtOf",
+    inputs: [
+      {
+        name: "",
+        type: "address",
+        internalType: "address"
+      },
+      {
+        name: "",
+        type: "bytes32",
+        internalType: "bytes32"
+      }
+    ],
+    outputs: [
+      {
+        name: "",
+        type: "uint256",
+        internalType: "uint256"
+      }
+    ],
+    stateMutability: "view"
+  }
+];
+
+// src/core/Fetchers.ts
+async function fetchBalancesAndAllowances(parameters) {
+  const { client, spender, pairs, options } = parameters;
+  if (pairs.length === 0) return /* @__PURE__ */ new Map();
+  const batchSize = Math.max(1, options?.batchSize ?? 5e3);
+  const retryAttempts = Math.max(1, options?.retryAttempts ?? 3);
+  const retryDelayMs = Math.max(0, options?.retryDelayMs ?? 50);
+  const blockNumber = options?.blockNumber ? BigInt(options.blockNumber) : void 0;
+  const out = /* @__PURE__ */ new Map();
+  for (const pairsBatch of mempool.Utils.batch(pairs, batchSize)) {
+    const balanceCalls = [];
+    const allowanceCalls = [];
+    for (const { user, token } of pairsBatch) {
+      balanceCalls.push({
+        address: token,
+        abi: viem.erc20Abi,
+        functionName: "balanceOf",
+        args: [user]
+      });
+      allowanceCalls.push({
+        address: token,
+        abi: viem.erc20Abi,
+        functionName: "allowance",
+        args: [user, spender]
+      });
+    }
+    const [balances, allowances] = await Promise.all([
+      mempool.Utils.retry(
+        () => client.multicall({
+          allowFailure: false,
+          contracts: balanceCalls,
+          ...blockNumber ? { blockNumber } : {}
+        }),
+        retryAttempts,
+        retryDelayMs
+      ),
+      mempool.Utils.retry(
+        () => client.multicall({
+          allowFailure: false,
+          contracts: allowanceCalls,
+          ...blockNumber ? { blockNumber } : {}
+        }),
+        retryAttempts,
+        retryDelayMs
+      )
+    ]);
+    for (let i = 0; i < pairsBatch.length; i++) {
+      const { user, token } = pairsBatch[i];
+      const balance = balances[i];
+      const allowance = allowances[i];
+      let perUser = out.get(user);
+      if (!perUser) {
+        perUser = /* @__PURE__ */ new Map();
+        out.set(user, perUser);
+      }
+      perUser.set(token, { balance, allowance });
+    }
+  }
+  return out;
 }
-async function match(config, parameters) {
-  const url = new URL(`${config.url.toString()}v1/offers/match`);
-  url.searchParams.set("side", parameters.side);
-  url.searchParams.set("chain_id", parameters.chainId.toString());
-  if (parameters.rate !== void 0) {
-    url.searchParams.set("rate", parameters.rate.toString());
-  }
-  if (parameters.collaterals?.length) {
-    const collateralsStr = parameters.collaterals.map(({ asset, oracle, lltv }) => `${asset}:${oracle}:${viem.formatUnits(lltv, 16)}`).join("#");
-    url.searchParams.set("collaterals", collateralsStr);
-  }
-  if (parameters.maturity !== void 0) {
-    url.searchParams.set("maturity", parameters.maturity.toString());
-  }
-  if (parameters.minMaturity !== void 0) {
-    url.searchParams.set("min_maturity", parameters.minMaturity.toString());
-  }
-  if (parameters.maxMaturity !== void 0) {
-    url.searchParams.set("max_maturity", parameters.maxMaturity.toString());
-  }
-  if (parameters.loanToken) {
-    url.searchParams.set("loan_token", parameters.loanToken);
-  }
-  if (parameters.creator) {
-    url.searchParams.set("creator", parameters.creator);
-  }
-  if (parameters.status?.length) {
-    url.searchParams.set("status", parameters.status.join(","));
-  }
-  if (parameters.cursor) {
-    url.searchParams.set("cursor", parameters.cursor);
-  }
-  if (parameters.limit !== void 0) {
-    url.searchParams.set("limit", parameters.limit.toString());
+async function fetchOraclePrices(parameters) {
+  const { client, oracles, options } = parameters;
+  if (oracles.length === 0) return /* @__PURE__ */ new Map();
+  const batchSize = Math.max(1, options?.batchSize ?? 5e3);
+  const retryAttempts = Math.max(1, options?.retryAttempts ?? 3);
+  const retryDelayMs = Math.max(0, options?.retryDelayMs ?? 50);
+  const blockNumber = options?.blockNumber ? BigInt(options.blockNumber) : void 0;
+  const out = /* @__PURE__ */ new Map();
+  for (const oraclesBatch of mempool.Utils.batch(oracles, batchSize)) {
+    const priceCalls = [];
+    for (const oracle of oraclesBatch) {
+      priceCalls.push({
+        address: oracle,
+        abi: Oracle,
+        functionName: "price",
+        args: []
+      });
+    }
+    const prices = await mempool.Utils.retry(
+      () => client.multicall({
+        allowFailure: false,
+        contracts: priceCalls,
+        ...blockNumber ? { blockNumber } : {}
+      }),
+      retryAttempts,
+      retryDelayMs
+    );
+    for (let i = 0; i < oraclesBatch.length; i++) {
+      const oracle = oraclesBatch[i];
+      const price = prices[i];
+      out.set(oracle, price);
+    }
   }
-  const { cursor: returnedCursor, data: offers } = await getApi(config, url);
-  const routerOffers = offers.map(mempool.Format.fromSnakeCase).map(fromResponse);
-  return {
-    cursor: returnedCursor,
-    offers: routerOffers.map(from).map(toResponse)
-  };
+  return out;
 }
-async function getApi(config, url) {
-  const pathname = url.pathname;
-  let action;
-  switch (true) {
-    case pathname.includes("/v1/offers/match"):
-      action = "match_offers";
-      break;
-    case pathname.includes("/v1/offers"):
-      action = "get_offers";
-      break;
-    default:
-      throw new HttpGetOffersFailedError("Unknown endpoint", {
-        details: `Unsupported path: ${pathname}`
+async function fetchCollateralAndDebt(parameters) {
+  const { client, morphoAddress, queries, options } = parameters;
+  if (queries.length === 0) return /* @__PURE__ */ new Map();
+  const batchSize = Math.max(1, options?.batchSize ?? 5e3);
+  const retryAttempts = Math.max(1, options?.retryAttempts ?? 3);
+  const retryDelayMs = Math.max(0, options?.retryDelayMs ?? 50);
+  const blockNumber = options?.blockNumber ? BigInt(options.blockNumber) : void 0;
+  const out = /* @__PURE__ */ new Map();
+  for (const queriesBatch of mempool.Utils.batch(queries, batchSize)) {
+    const collateralCalls = [];
+    const debtCalls = [];
+    for (const { user, termId, collateralAssets } of queriesBatch) {
+      debtCalls.push({
+        address: morphoAddress,
+        abi: Morpho,
+        functionName: "debtOf",
+        args: [user, termId]
       });
+      for (const collateralAsset of collateralAssets) {
+        collateralCalls.push({
+          address: morphoAddress,
+          abi: Morpho,
+          functionName: "collateralOf",
+          args: [user, termId, collateralAsset]
+        });
+      }
+    }
+    const [collateralResults, debtResults] = await Promise.all([
+      mempool.Utils.retry(
+        () => client.multicall({
+          allowFailure: false,
+          contracts: collateralCalls,
+          ...blockNumber ? { blockNumber } : {}
+        }),
+        retryAttempts,
+        retryDelayMs
+      ),
+      mempool.Utils.retry(
+        () => client.multicall({
+          allowFailure: false,
+          contracts: debtCalls,
+          ...blockNumber ? { blockNumber } : {}
+        }),
+        retryAttempts,
+        retryDelayMs
+      )
+    ]);
+    let collateralIndex = 0;
+    for (let queryIndex = 0; queryIndex < queriesBatch.length; queryIndex++) {
+      const { user, termId, collateralAssets } = queriesBatch[queryIndex];
+      const debt = debtResults[queryIndex];
+      const collateralByAsset = /* @__PURE__ */ new Map();
+      for (const collateralAsset of collateralAssets) {
+        const collateralAmount = collateralResults[collateralIndex];
+        collateralByAsset.set(collateralAsset.toLowerCase(), collateralAmount);
+        collateralIndex++;
+      }
+      let perUser = out.get(user);
+      if (!perUser) {
+        perUser = /* @__PURE__ */ new Map();
+        out.set(user, perUser);
+      }
+      perUser.set(termId, {
+        collateralByAsset,
+        debt
+      });
+    }
   }
-  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",
-    headers: config.headers
+  return out;
+}
+
+// src/core/Liquidity.ts
+async function fetchMaxBorrowCapacity(parameters) {
+  const { client, collaterals, existingDebt, options } = parameters;
+  if (collaterals.length === 0) return 0n;
+  const uniqueOracles = [...new Set(collaterals.map((c) => c.oracle))];
+  const oraclePrices = await fetchOraclePrices({
+    client,
+    oracles: uniqueOracles,
+    options
   });
-  if (!response.ok) {
-    switch (response.status) {
-      case 401:
-        throw new HttpUnauthorizedError();
-      case 403:
-        throw new HttpForbiddenError();
-      case 429:
-        throw new HttpRateLimitError();
+  const ORACLE_PRICE_SCALE = 10n ** 36n;
+  const PRECISION = 10n ** 18n;
+  let maxDebt = 0n;
+  for (const collateral of collaterals) {
+    const price = oraclePrices.get(collateral.oracle);
+    if (!price) continue;
+    const collateralQuoted = collateral.totalAmount * price / ORACLE_PRICE_SCALE;
+    const collateralMaxDebt = collateralQuoted * collateral.lltv / PRECISION;
+    maxDebt = maxDebt + collateralMaxDebt;
+  }
+  if (existingDebt > 0n) {
+    if (maxDebt > existingDebt) {
+      maxDebt = maxDebt - existingDebt;
+    } else {
+      maxDebt = 0n;
     }
-    throw new HttpGetOffersFailedError(`GET request returned ${response.status}`, {
-      details: await response.text()
-    });
   }
-  return response.json();
+  return maxDebt;
 }
-var InvalidUrlError = class extends mempool.Errors.BaseError {
-  constructor(url) {
-    super(`URL "${url}" is not http/https.`);
-    __publicField(this, "name", "Router.InvalidUrlError");
-  }
+var create = (config) => {
+  const { client } = config;
+  return {
+    fetchBuyLiquidity: (parameters) => fetchBuyLiquidity({ ...parameters, client }),
+    fetchSellLiquidity: (parameters) => fetchSellLiquidity({ ...parameters, client })
+  };
 };
-var HttpUnauthorizedError = class extends mempool.Errors.BaseError {
-  constructor() {
-    super("Unauthorized.", {
-      metaMessages: ["Ensure that an API key is provided."]
-    });
-    __publicField(this, "name", "Router.HttpUnauthorizedError");
+async function fetchBuyLiquidity(parameters) {
+  const { client, chainId, spender, pairs, options } = parameters;
+  const map = await fetchBalancesAndAllowances({
+    client,
+    spender,
+    pairs: pairs.map(({ user, loanToken }) => ({ user, token: loanToken })),
+    options
+  });
+  const out = [];
+  for (const [user, perLoanToken] of map) {
+    for (const [loanToken, { balance, allowance }] of perLoanToken) {
+      const amount = balance < allowance ? balance : allowance;
+      out.push(
+        buildLiquidity({
+          type: "buy_with_empty_callback" /* BuyWithEmptyCallback */,
+          user,
+          loanToken,
+          chainId,
+          amount,
+          index: 0
+        })
+      );
+    }
   }
-};
-var HttpForbiddenError = class extends mempool.Errors.BaseError {
-  constructor() {
-    super("Forbidden.", {
-      metaMessages: ["Ensure that the API key is valid."]
+  return out;
+}
+async function fetchSellLiquidity(parameters) {
+  const { client, chainId, spender, morphoAddress, offers, options } = parameters;
+  const collateralPairs = [];
+  for (const offer of offers) {
+    const user = offer.offering;
+    const callbackData = decode2({
+      type: "sell_erc20_callback" /* SellERC20Callback */,
+      data: offer.callback.data
     });
-    __publicField(this, "name", "Router.HttpForbiddenError");
+    for (const { collateral } of callbackData) {
+      collateralPairs.push({ user, token: collateral });
+    }
   }
-};
-var HttpRateLimitError = class extends mempool.Errors.BaseError {
-  constructor() {
-    super("Rate limit exceeded.", {
-      metaMessages: [
-        "The number of allowed requests has been exceeded. You must wait for the rate limit to reset."
-      ]
+  const map = await fetchBalancesAndAllowances({
+    client,
+    spender,
+    pairs: collateralPairs,
+    options
+  });
+  const collateralDebt = [];
+  for (const offer of offers) {
+    const user = offer.offering;
+    const termId = mempool.Offer.termId(offer);
+    const collateralAssets = offer.collaterals.map((collateral) => collateral.asset);
+    collateralDebt.push({
+      user,
+      termId,
+      collateralAssets
     });
-    __publicField(this, "name", "Router.HttpRateLimitError");
   }
-};
-var HttpGetOffersFailedError = class extends mempool.Errors.BaseError {
-  constructor(message, { details } = {}) {
-    super(message, {
-      metaMessages: [details]
+  const existingPositions = await fetchCollateralAndDebt({
+    client,
+    morphoAddress,
+    queries: collateralDebt,
+    options
+  });
+  const out = [];
+  for (const offer of offers) {
+    const user = offer.offering;
+    const termId = mempool.Offer.termId(offer);
+    const callbackData = decode2({
+      type: "sell_erc20_callback" /* SellERC20Callback */,
+      data: offer.callback.data
     });
-    __publicField(this, "name", "Router.HttpGetOffersFailedError");
+    const callbackCollaterals = callbackData.map((callbackItem) => {
+      const userMap = map.get(user);
+      const tokenData = userMap?.get(callbackItem.collateral);
+      if (!tokenData) return null;
+      const offerCollateral = offer.collaterals.find(
+        (c) => c.asset.toLowerCase() === callbackItem.collateral.toLowerCase()
+      );
+      if (!offerCollateral) return null;
+      const { balance, allowance } = tokenData;
+      const availableAmount = balance < allowance ? balance : allowance;
+      return {
+        collateralAddress: callbackItem.collateral,
+        balance: availableAmount,
+        callbackAmount: callbackItem.amount
+      };
+    }).filter((collateral) => collateral !== null);
+    if (callbackCollaterals.length === 0) continue;
+    const existingPosition = existingPositions.get(user)?.get(termId);
+    const collaterals = offer.collaterals.map((c) => {
+      const callbackCollateral = callbackCollaterals.find(
+        (cc) => cc.collateralAddress.toLowerCase() === c.asset.toLowerCase()
+      );
+      const callbackAmount = callbackCollateral?.balance ?? 0n;
+      const existingAmount = existingPosition?.collateralByAsset.get(c.asset.toLowerCase()) ?? 0n;
+      return {
+        asset: c.asset,
+        oracle: c.oracle,
+        lltv: c.lltv,
+        totalAmount: existingAmount + callbackAmount
+      };
+    });
+    const existingDebt = existingPosition?.debt ?? 0n;
+    const userPositionAmount = await fetchMaxBorrowCapacity({
+      client,
+      collaterals,
+      existingDebt,
+      options
+    });
+    out.push(
+      buildLiquidity({
+        type: "sell_erc20_callback" /* SellERC20Callback */,
+        user,
+        termId,
+        offerHash: offer.hash,
+        chainId,
+        amount: userPositionAmount,
+        collaterals: callbackCollaterals,
+        index: 0
+      })
+    );
   }
-};
+  return out;
+}
+function serialize(liquidity) {
+  const normalized = {
+    userPosition: {
+      id: liquidity.userPosition.id,
+      availableLiquidityQueueId: liquidity.userPosition.availableLiquidityQueueId,
+      user: liquidity.userPosition.user,
+      chainId: String(liquidity.userPosition.chainId),
+      amount: String(liquidity.userPosition.amount)
+    },
+    queues: liquidity.queues.map((queueWithPool) => ({
+      queue: {
+        queueId: queueWithPool.queue.queueId,
+        availableLiquidityPoolId: queueWithPool.queue.availableLiquidityPoolId,
+        index: queueWithPool.queue.index
+      },
+      pool: {
+        id: queueWithPool.pool.id,
+        amount: String(queueWithPool.pool.amount)
+      }
+    })).sort(
+      (left, right) => {
+        const leftQueueId = left.queue.queueId || "";
+        const rightQueueId = right.queue.queueId || "";
+        if (leftQueueId < rightQueueId) return -1;
+        if (leftQueueId > rightQueueId) return 1;
+        const leftPoolId = left.pool.id;
+        const rightPoolId = right.pool.id;
+        if (leftPoolId < rightPoolId) return -1;
+        if (leftPoolId > rightPoolId) return 1;
+        const leftIndex = left.queue.index;
+        const rightIndex = right.queue.index;
+        if (leftIndex < rightIndex) return -1;
+        if (leftIndex > rightIndex) return 1;
+        return 0;
+      }
+    )
+  };
+  return JSON.stringify(normalized);
+}
 
 // src/core/Validation.ts
 var Validation_exports = {};
@@ -1268,7 +1624,7 @@ function morpho() {
     (offer, _) => {
       if (!offer.buy && offer.callback.data !== "0x") {
         const allowed = new Set(
-          WhitelistedCallbackAddresses["sell_withdraw_from_wallet" /* SellWithdrawFromWallet */].map(
+          WhitelistedCallbackAddresses["sell_erc20_callback" /* SellERC20Callback */].map(
             (a) => a.toLowerCase()
           )
         );
@@ -1284,8 +1640,8 @@ function morpho() {
     (offer, _) => {
       if (!offer.buy && offer.callback.data !== "0x") {
         try {
-          const decoded = decode({
-            type: "sell_withdraw_from_wallet" /* SellWithdrawFromWallet */,
+          const decoded = decode2({
+            type: "sell_erc20_callback" /* SellERC20Callback */,
             data: offer.callback.data
           });
           if (decoded.length === 0) {
@@ -1302,8 +1658,8 @@ function morpho() {
     (offer, _) => {
       if (!offer.buy && offer.callback.data !== "0x") {
         try {
-          const decoded = decode({
-            type: "sell_withdraw_from_wallet" /* SellWithdrawFromWallet */,
+          const decoded = decode2({
+            type: "sell_erc20_callback" /* SellERC20Callback */,
             data: offer.callback.data
           });
           const offerCollaterals = new Set(
@@ -1319,10 +1675,19 @@ function morpho() {
       }
     }
   );
+  const maturity = single("maturity", (offer, _) => {
+    const allowedMaturities = [mempool.Maturity.from("end_of_month"), mempool.Maturity.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}`
+      };
+    }
+  });
   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,
@@ -1336,7 +1701,7 @@ function morpho() {
 exports.Callback = Callback_exports;
 exports.Cursor = Cursor_exports;
 exports.Liquidity = Liquidity_exports;
-exports.Router = Client_exports;
+exports.RouterApi = Client_exports;
 exports.RouterOffer = RouterOffer_exports;
 exports.Validation = Validation_exports;
 exports.ValidationRule = ValidationRule_exports;