@morpho-dev/router 0.1.2 → 0.1.4

package/dist/index.browser.mjs

@@ -1,9 +1,9 @@
-import { Errors, LLTV, Offer, Format, Time, Maturity, Chain } from '@morpho-dev/mempool';
+import { Errors, LLTV, Offer, Format, Utils, Time, Maturity } from '@morpho-dev/mempool';
 export * from '@morpho-dev/mempool';
-import { parseUnits, maxUint256, formatUnits, parseAbi } from 'viem';
+import { Base64 } from 'js-base64';
+import { parseUnits, maxUint256, formatUnits, erc20Abi } from 'viem';
 import { z } from 'zod/v4';
 import { createDocument } from 'zod-openapi';
-import { Base64 } from '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;
@@ -13,6 +13,145 @@ var __export = (target, all) => {
 };
 var __publicField = (obj, key, value) => __defNormalProp(obj, key + "" , value);
 
+// src/Callback.ts
+var Callback_exports = {};
+__export(Callback_exports, {
+  CallbackType: () => CallbackType,
+  buildLiquidity: () => buildLiquidity,
+  getCallbackIdForOffer: () => getCallbackIdForOffer
+});
+var CallbackType = /* @__PURE__ */ ((CallbackType2) => {
+  CallbackType2["BuyWithEmptyCallback"] = "buy_with_empty_callback";
+  return CallbackType2;
+})(CallbackType || {});
+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;
+}
+
+// src/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}`
+    );
+  }
+  return true;
+}
+function encode(c) {
+  return Base64.encodeURL(JSON.stringify(c));
+}
+function decode(token) {
+  if (!token) return null;
+  const decoded = JSON.parse(Base64.decode(token));
+  validate(decoded);
+  return decoded;
+}
+
 // src/core/router/Client.ts
 var Client_exports = {};
 __export(Client_exports, {
@@ -106,140 +245,6 @@ var InvalidRouterOfferError = class extends Errors.BaseError {
   }
 };
 
-// src/utils/index.ts
-var utils_exports = {};
-__export(utils_exports, {
-  batch: () => batch,
-  decodeCursor: () => decodeCursor,
-  encodeCursor: () => encodeCursor,
-  poll: () => poll,
-  retry: () => retry,
-  validateCursor: () => validateCursor,
-  wait: () => wait
-});
-
-// src/utils/batch.ts
-function* batch(array, batchSize) {
-  for (let i = 0; i < array.length; i += batchSize) {
-    yield array.slice(i, i + batchSize);
-  }
-}
-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 Base64.encodeURL(JSON.stringify(c));
-}
-function decodeCursor(token) {
-  if (!token) return null;
-  const decoded = JSON.parse(Base64.decode(token));
-  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/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/core/apiSchema/requests.ts
 var MAX_LIMIT = 100;
 var DEFAULT_LIMIT = 20;
@@ -417,7 +422,7 @@ var GetOffersQueryParams = z.object({
     (val) => {
       if (!val) return true;
       try {
-        const decoded = decodeCursor(val);
+        const decoded = decode(val);
         return decoded !== null;
       } catch (_error) {
         return false;
@@ -584,21 +589,12 @@ var MatchOffersQueryParams = z.object({
     description: "Filter by a specific offer creator address",
     example: "0x1234567890123456789012345678901234567890"
   }),
-  // Status filtering
-  status: 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: z.string().optional().refine(
     (val) => {
       if (!val) return true;
       try {
-        const decoded = decodeCursor(val);
+        const decoded = decode(val);
         return decoded !== null;
       } catch (_error) {
         return false;
@@ -991,6 +987,140 @@ var HttpGetOffersFailedError = class extends Errors.BaseError {
   }
 };
 
+// src/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 Utils.batch(pairs, batchSize)) {
+    const balanceContracts = [];
+    const allowanceContracts = [];
+    for (const { user, token } of pairsBatch) {
+      balanceContracts.push({
+        address: token,
+        abi: erc20Abi,
+        functionName: "balanceOf",
+        args: [user]
+      });
+      allowanceContracts.push({
+        address: token,
+        abi: erc20Abi,
+        functionName: "allowance",
+        args: [user, spender]
+      });
+    }
+    const [balances, allowances] = await Promise.all([
+      Utils.retry(
+        () => client.multicall({
+          allowFailure: false,
+          contracts: balanceContracts,
+          ...blockNumber ? { blockNumber } : {}
+        }),
+        retryAttempts,
+        retryDelayMs
+      ),
+      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/OfferStore/index.ts
 var OfferStore_exports = {};
 __export(OfferStore_exports, {
@@ -1002,8 +1132,10 @@ function memory(parameters) {
   const consumedIds = /* @__PURE__ */ new Set();
   const create = async (parameters2) => {
     if (map.has(parameters2.offer.hash.toLowerCase())) return parameters2.offer.hash;
+    const callbackId = getCallbackIdForOffer(parameters2.offer);
     map.set(parameters2.offer.hash.toLowerCase(), {
       ...parameters2.offer,
+      ...callbackId ? { callbackId } : {},
       status: parameters2.status,
       metadata: parameters2.metadata
     });
@@ -1098,7 +1230,7 @@ function memory(parameters) {
         ...o,
         consumed: filled.get(o.chainId)?.get(o.offering.toLowerCase())?.get(o.nonce) || 0n
       })).filter((o) => o.consumed < o.assets);
-      const cursor = decodeCursor(queryCursor);
+      const cursor = decode(queryCursor);
       if (cursor) {
         if (cursor.sort !== sortBy || cursor.dir !== sortOrder) {
           throw new Error("Cursor does not match the current sort parameters");
@@ -1196,11 +1328,35 @@ function memory(parameters) {
           default:
             base.expiry = last.expiry;
         }
-        nextCursor = encodeCursor(base);
+        nextCursor = encode(base);
       }
       offers = offers.slice(0, limit);
+      const data = offers.map((o) => ({
+        ...Offer.from({
+          offering: o.offering,
+          assets: o.assets,
+          rate: o.rate,
+          maturity: Maturity.from(o.maturity),
+          expiry: o.expiry,
+          start: o.start,
+          nonce: o.nonce,
+          buy: o.buy,
+          chainId: o.chainId,
+          loanToken: o.loanToken,
+          collaterals: o.collaterals.map((c) => ({ asset: c.asset, oracle: c.oracle, lltv: c.lltv })).sort((a, b) => a.asset.toLowerCase().localeCompare(b.asset.toLowerCase())),
+          callback: {
+            address: o.callback.address,
+            data: o.callback.data,
+            gasLimit: o.callback.gasLimit
+          },
+          ...o.signature !== null && o.signature !== void 0 ? { signature: o.signature } : {}
+        }),
+        consumed: o.consumed,
+        status: o.status,
+        ...o.metadata ? { metadata: o.metadata } : {}
+      }));
       return {
-        offers,
+        offers: data,
         nextCursor
       };
     },
@@ -1215,7 +1371,6 @@ function memory(parameters) {
         maxMaturity,
         loanToken,
         creator,
-        status,
         cursor: queryCursor,
         limit = 20
       } = params;
@@ -1226,7 +1381,7 @@ function memory(parameters) {
         ...o,
         consumed: filled.get(o.chainId)?.get(o.offering.toLowerCase())?.get(o.nonce) || 0n
       })).filter((o) => o.consumed < o.assets);
-      const cursor = decodeCursor(queryCursor);
+      const cursor = decode(queryCursor);
       if (cursor) {
         if (cursor.sort !== "rate" || cursor.dir !== sortOrder) {
           throw new Error("Cursor does not match the current sort parameters");
@@ -1261,7 +1416,7 @@ function memory(parameters) {
       maxMaturity && (offers = offers.filter((o) => o.maturity <= maxMaturity));
       loanToken && (offers = offers.filter((o) => o.loanToken.toLowerCase() === loanToken.toLowerCase()));
       creator && (offers = offers.filter((o) => o.offering.toLowerCase() === creator.toLowerCase()));
-      status && (offers = offers.filter((o) => status.includes(o.status)));
+      offers = offers.filter((o) => ["valid"].includes(o.status));
       const byGroup = /* @__PURE__ */ new Map();
       for (const offer of offers) {
         const groupKey = `${offer.chainId}-${offer.offering.toLowerCase()}-${offer.nonce}-${offer.buy}`;
@@ -1296,7 +1451,7 @@ function memory(parameters) {
       let nextCursor = null;
       if (offers.length > limit) {
         const last = offers[limit - 1];
-        nextCursor = encodeCursor({
+        nextCursor = encode({
           sort: "rate",
           dir: sortOrder,
           hash: last.hash,
@@ -1304,8 +1459,32 @@ function memory(parameters) {
         });
       }
       offers = offers.slice(0, limit);
+      const data = offers.map((o) => ({
+        ...Offer.from({
+          offering: o.offering,
+          assets: o.assets,
+          rate: o.rate,
+          maturity: Maturity.from(o.maturity),
+          expiry: o.expiry,
+          start: o.start,
+          nonce: o.nonce,
+          buy: o.buy,
+          chainId: o.chainId,
+          loanToken: o.loanToken,
+          collaterals: o.collaterals.map((c) => ({ asset: c.asset, oracle: c.oracle, lltv: c.lltv })).sort((a, b) => a.asset.toLowerCase().localeCompare(b.asset.toLowerCase())),
+          callback: {
+            address: o.callback.address,
+            data: o.callback.data,
+            gasLimit: o.callback.gasLimit
+          },
+          ...o.signature !== null && o.signature !== void 0 ? { signature: o.signature } : {}
+        }),
+        consumed: o.consumed,
+        status: o.status,
+        ...o.metadata ? { metadata: o.metadata } : {}
+      }));
       return {
-        offers,
+        offers: data,
         nextCursor
       };
     },
@@ -1351,18 +1530,6 @@ function memory(parameters) {
   };
 }
 
-// src/RouterEvent.ts
-var RouterEvent_exports = {};
-__export(RouterEvent_exports, {
-  from: () => from2,
-  types: () => types
-});
-var types = ["offer_created", "offer_consumed", "offer_validation"];
-function from2(base) {
-  const id = base.type === "offer_consumed" ? `${base.type}:${base.offerConsumed.id}` : `${base.type}:${base.offer.hash.toLowerCase()}`;
-  return { id, ...base };
-}
-
 // src/Validation.ts
 var Validation_exports = {};
 __export(Validation_exports, {
@@ -1413,35 +1580,29 @@ async function run(parameters) {
 // src/ValidationRule.ts
 var ValidationRule_exports = {};
 __export(ValidationRule_exports, {
-  batch: () => batch2,
+  batch: () => batch,
   morpho: () => morpho,
   single: () => single
 });
 function single(name, run2) {
   return { kind: "single", name, run: run2 };
 }
-function batch2(name, run2) {
+function batch(name, run2) {
   return { kind: "batch", name, run: run2 };
 }
-function morpho(parameters) {
-  const { whitelistedChains } = parameters;
-  const whitelistedChainIds = new Set(whitelistedChains.map((chain) => chain.id));
-  const whitelistedLoanTokensPerChain = new Map(
-    whitelistedChains.map((chain) => [
-      chain.id,
-      new Set(Array.from(chain.whitelistedAssets).map((a) => a.toLowerCase()))
-    ])
-  );
-  const morphoPerChain = new Map(
-    whitelistedChains.map((chain) => [chain.id, chain.morpho.toLowerCase()])
-  );
-  const chainId = single("chain_id", (offer, _) => {
-    if (!whitelistedChainIds.has(offer.chainId)) {
-      return { message: `Chain ID ${offer.chainId} is not whitelisted` };
+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, _) => {
-    if (!whitelistedLoanTokensPerChain.get(offer.chainId)?.has(offer.loanToken.toLowerCase())) {
+  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}`
       };
@@ -1452,130 +1613,21 @@ function morpho(parameters) {
       return { message: "Expiry mismatch" };
     }
   });
-  const emptyCallback = single("empty_callback", (offer, _) => {
-    if (offer.callback.data !== "0x") {
-      return { message: "Callback data is not empty. Not supported yet." };
+  const callback = single("empty_callback", (offer, _) => {
+    if (!offer.buy || offer.callback.data !== "0x") {
+      return { message: "Callback not supported yet." };
     }
   });
-  const sellOffersEmptyCallback = single(
-    "sell_offers_empty_callback",
-    (offer, _) => {
-      if (!offer.buy && offer.callback.data === "0x") {
-        return { message: "Sell offers with empty callback are not supported yet." };
-      }
-    }
-  );
-  const buyOffersEmptyCallback = batch2(
-    "buy_offers_empty_callback",
-    async (offers, { publicClients }) => {
-      const issues = /* @__PURE__ */ new Map();
-      const hashToIndex = /* @__PURE__ */ new Map();
-      for (let i = 0; i < offers.length; i++) {
-        const offer = offers[i];
-        hashToIndex.set(offer.hash, i);
-      }
-      const { buyOffers, sellOffers: _sellOffers } = offers.reduce(
-        (acc, offer) => {
-          offer.buy ? acc.buyOffers.push(offer) : issues.set(hashToIndex.get(offer.hash), {
-            message: "Onchain callback for sell offers is not supported yet."
-          });
-          return acc;
-        },
-        { buyOffers: [], sellOffers: [] }
-      );
-      const buyOffersPerLoanAsset = /* @__PURE__ */ new Map();
-      for (const offer of buyOffers) {
-        const chainName = Chain.getChain(offer.chainId)?.name;
-        const loanTokens = buyOffersPerLoanAsset.get(chainName) ?? /* @__PURE__ */ new Map();
-        const offers2 = loanTokens.get(offer.loanToken.toLowerCase()) ?? [];
-        offers2.push(offer);
-        loanTokens.set(offer.loanToken.toLowerCase(), offers2);
-        buyOffersPerLoanAsset.set(chainName, loanTokens);
-      }
-      await Promise.all(
-        Array.from(buyOffersPerLoanAsset.entries()).map(async ([name, loanTokens]) => {
-          const chainName = name;
-          const publicClient = publicClients[chainName];
-          const morpho2 = morphoPerChain.get(Chain.chains[chainName].id);
-          if (!publicClient) {
-            const offers2 = Array.from(loanTokens.values()).flat();
-            for (const offer of offers2) {
-              issues.set(hashToIndex.get(offer.hash), {
-                message: `Public client for chain "${chainName}" is not available`
-              });
-            }
-            return;
-          }
-          const balances = /* @__PURE__ */ new Map();
-          const allowances = /* @__PURE__ */ new Map();
-          for (const [loanToken2, offers2] of loanTokens) {
-            const data = await Promise.all(
-              offers2.flatMap((offer) => [
-                publicClient.readContract({
-                  address: loanToken2,
-                  abi: parseAbi([
-                    "function balanceOf(address owner) view returns (uint256 balance)"
-                  ]),
-                  functionName: "balanceOf",
-                  args: [offer.offering]
-                }),
-                publicClient.readContract({
-                  address: loanToken2,
-                  abi: parseAbi([
-                    "function allowance(address owner, address spender) public view returns (uint256 remaining)"
-                  ]),
-                  functionName: "allowance",
-                  args: [offer.offering, morpho2]
-                })
-              ])
-            );
-            for (let i = 0; i < offers2.length; i++) {
-              const user = offers2[i].offering.toLowerCase();
-              const balance = data[i * 2] || 0n;
-              const allowance = data[i * 2 + 1] || 0n;
-              const userBalances = balances.get(user) ?? /* @__PURE__ */ new Map();
-              userBalances.set(loanToken2.toLowerCase(), balance);
-              const userAllowances = allowances.get(user) ?? /* @__PURE__ */ new Map();
-              userAllowances.set(loanToken2.toLowerCase(), allowance);
-              balances.set(user, userBalances);
-              allowances.set(user, userAllowances);
-            }
-          }
-          for (const offer of Array.from(loanTokens.values()).flat()) {
-            const user = offer.offering.toLowerCase();
-            const userBalances = balances.get(user);
-            const balance = userBalances?.get(offer.loanToken.toLowerCase());
-            if (balance < offer.assets) {
-              issues.set(hashToIndex.get(offer.hash), {
-                message: `Insufficient balance for ${offer.loanToken} on chain ${offer.chainId} (${balance.toString()} < ${offer.assets.toString()})`
-              });
-              continue;
-            }
-            const userAllowances = allowances.get(user);
-            const allowance = userAllowances?.get(offer.loanToken.toLowerCase());
-            if (allowance < offer.assets) {
-              issues.set(hashToIndex.get(offer.hash), {
-                message: `Insufficient allowance for ${offer.loanToken} on chain ${offer.chainId} (${allowance.toString()} < ${offer.assets.toString()})`
-              });
-            }
-          }
-        })
-      );
-      return issues;
-    }
-  );
   return [
     chainId,
     loanToken,
     expiry,
-    // note: callback onchain check should be done last since it does not mean that the offer is forever invalid
-    // integrators should be able to keep the offers that have an invalid callback onchain and be sure that is the only check that is not valid
-    emptyCallback,
-    sellOffersEmptyCallback,
-    buyOffersEmptyCallback
+    // note: callback rule should be the last one, since it does not mean that the offer is forever invalid
+    // integrators should be able to choose if they want to keep the offer or not
+    callback
   ];
 }
 
-export { OfferStore_exports as OfferStore, Client_exports as Router, RouterEvent_exports as RouterEvent, RouterOffer_exports as RouterOffer, utils_exports as Utils, Validation_exports as Validation, ValidationRule_exports as ValidationRule };
+export { Callback_exports as Callback, Cursor_exports as Cursor, Liquidity_exports as Liquidity, OfferStore_exports as OfferStore, Client_exports as Router, RouterOffer_exports as RouterOffer, Validation_exports as Validation, ValidationRule_exports as ValidationRule };
 //# sourceMappingURL=index.browser.mjs.map
 //# sourceMappingURL=index.browser.mjs.map