@morpho-dev/router 0.1.9 → 0.1.11

package/dist/index.browser.mjs

@@ -1,7 +1,7 @@
-import { Errors, LLTV, Utils, Offer, Format } from '@morpho-dev/mempool';
+import { Errors, LLTV, Offer, Utils, Format } from '@morpho-dev/mempool';
 export * from '@morpho-dev/mempool';
+import { parseUnits, encodeAbiParameters, maxUint256, formatUnits, decodeAbiParameters, erc20Abi } from 'viem';
 import { Base64 } from 'js-base64';
-import { parseUnits, maxUint256, formatUnits, erc20Abi } from 'viem';
 import { z } from 'zod/v4';
 import { createDocument } from 'zod-openapi';
 
@@ -17,60 +17,153 @@ var __publicField = (obj, key, value) => __defNormalProp(obj, key + "" , value);
 var Callback_exports = {};
 __export(Callback_exports, {
   CallbackType: () => CallbackType,
+  WhitelistedCallbackAddresses: () => WhitelistedCallbackAddresses,
   buildLiquidity: () => buildLiquidity,
+  decode: () => decode,
+  encode: () => encode,
   getCallbackIdForOffer: () => getCallbackIdForOffer
 });
 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
+  ].map((address) => address.toLowerCase())
+};
 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,
+  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
         },
-        pool: {
+        queues: [
+          {
+            queue: {
+              queueId: id,
+              availableLiquidityPoolId: poolId,
+              index,
+              callbackAmount: "0",
+              updatedAt
+            },
+            pool: {
+              id: poolId,
+              amount: amountStr,
+              updatedAt
+            }
+          }
+        ]
+      };
+    }
+    case "sell_withdraw_from_wallet" /* SellWithdrawFromWallet */: {
+      const {
+        user,
+        termId,
+        chainId,
+        amount,
+        collaterals,
+        index = 0,
+        updatedAt = /* @__PURE__ */ new Date()
+      } = parameters;
+      const amountStr = amount.toString();
+      const id = `${user}-${chainId.toString()}-${parameters.type}-${termId}`.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") {
-    const type = "buy_with_empty_callback" /* BuyWithEmptyCallback */;
-    const user = offer.offering;
-    const loanToken = offer.loanToken;
-    return `${user}-${offer.chainId.toString()}-${type}-${loanToken}`.toLowerCase();
+    return `${offer.offering}-${offer.chainId.toString()}-${"buy_with_empty_callback" /* BuyWithEmptyCallback */}-${offer.loanToken}`.toLowerCase();
+  }
+  if (!offer.buy && offer.callback.data !== "0x" && WhitelistedCallbackAddresses["sell_withdraw_from_wallet" /* SellWithdrawFromWallet */].includes(
+    offer.callback.address.toLowerCase()
+  )) {
+    return `${offer.offering}-${offer.chainId.toString()}-${"sell_withdraw_from_wallet" /* SellWithdrawFromWallet */}-${Offer.termId(offer)}`.toLowerCase();
   }
   return null;
 }
+function decodeSellWithdrawFromWalletData(data) {
+  if (!data || data === "0x") throw new Error("Empty callback data");
+  try {
+    const [collaterals, amounts] = 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");
+  }
+}
+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 encode(parameters) {
+  const { type, data } = parameters;
+  if (type === "sell_withdraw_from_wallet" /* SellWithdrawFromWallet */) {
+    return encodeAbiParameters(
+      [{ type: "address[]" }, { type: "uint256[]" }],
+      [data.collaterals, data.amounts]
+    );
+  }
+  throw new Error(`CallbackType not implemented: ${type}`);
+}
 
 // src/core/Cursor.ts
 var Cursor_exports = {};
 __export(Cursor_exports, {
-  decode: () => decode,
-  encode: () => encode,
+  decode: () => decode2,
+  encode: () => encode2,
   validate: () => validate
 });
 function validate(cursor) {
@@ -142,10 +235,10 @@ function validate(cursor) {
   }
   return true;
 }
-function encode(c) {
+function encode2(c) {
   return Base64.encodeURL(JSON.stringify(c));
 }
-function decode(token) {
+function decode2(token) {
   if (!token) return null;
   const decoded = JSON.parse(Base64.decode(token));
   validate(decoded);
@@ -225,20 +318,20 @@ async function fetch2(parameters) {
   const map = await fetchBalancesAndAllowances({
     client,
     spender,
-    pairs: pairs.map(({ user, contract }) => ({ user, token: contract })),
+    pairs: pairs.map(({ user, loanToken }) => ({ user, token: loanToken })),
     options
   });
   const out = [];
-  for (const [user, perContract] of map) {
-    for (const [contract, { balance, allowance }] of perContract) {
+  for (const [user, perLoanToken] of map) {
+    for (const [loanToken, { balance, allowance }] of perLoanToken) {
       const amount = balance < allowance ? balance : allowance;
       out.push(
         buildLiquidity({
           type,
           user,
-          contract,
+          loanToken,
           chainId,
-          amount: amount.toString(),
+          amount,
           index: 0
         })
       );
@@ -554,7 +647,7 @@ var GetOffersQueryParams = z.object({
     (val) => {
       if (!val) return true;
       try {
-        const decoded = decode(val);
+        const decoded = decode2(val);
         return decoded !== null;
       } catch (_error) {
         return false;
@@ -726,7 +819,7 @@ var MatchOffersQueryParams = z.object({
     (val) => {
       if (!val) return true;
       try {
-        const decoded = decode(val);
+        const decoded = decode2(val);
         return decoded !== null;
       } catch (_error) {
         return false;
@@ -1202,18 +1295,89 @@ function morpho() {
       return { message: "Expiry mismatch" };
     }
   });
-  const callback = single("empty_callback", (offer, _) => {
-    if (!offer.buy || offer.callback.data !== "0x") {
-      return { message: "Callback not supported yet." };
+  const sellEmptyCallback = single(
+    "sell_offers_empty_callback",
+    (offer, _) => {
+      if (!offer.buy && offer.callback.data === "0x") {
+        return { message: "Sell offers require a non-empty callback." };
+      }
     }
-  });
+  );
+  const buyNonEmptyCallback = single(
+    "buy_offers_non_empty_callback",
+    (offer, _) => {
+      if (offer.buy && offer.callback.data !== "0x") {
+        return { message: "Buy offers must use an empty callback." };
+      }
+    }
+  );
+  const sellNonWhitelistedCallback = single(
+    "sell_offers_non_whitelisted_callback",
+    (offer, _) => {
+      if (!offer.buy && offer.callback.data !== "0x") {
+        const allowed = new Set(
+          WhitelistedCallbackAddresses["sell_withdraw_from_wallet" /* SellWithdrawFromWallet */].map(
+            (a) => a.toLowerCase()
+          )
+        );
+        const callbackAddress = offer.callback.address?.toLowerCase();
+        if (!callbackAddress || !allowed.has(callbackAddress)) {
+          return { message: "Sell offer callback address is not whitelisted." };
+        }
+      }
+    }
+  );
+  const sellCallbackDataInvalid = single(
+    "sell_offers_callback_data_invalid",
+    (offer, _) => {
+      if (!offer.buy && offer.callback.data !== "0x") {
+        try {
+          const decoded = decode({
+            type: "sell_withdraw_from_wallet" /* SellWithdrawFromWallet */,
+            data: offer.callback.data
+          });
+          if (decoded.length === 0) {
+            return { message: "Sell offer callback data must include at least one collateral." };
+          }
+        } catch (_2) {
+          return { message: "Sell offer callback data cannot be decoded." };
+        }
+      }
+    }
+  );
+  const sellCallbackCollateralInvalid = single(
+    "sell_offers_callback_collateral_invalid",
+    (offer, _) => {
+      if (!offer.buy && offer.callback.data !== "0x") {
+        try {
+          const decoded = decode({
+            type: "sell_withdraw_from_wallet" /* SellWithdrawFromWallet */,
+            data: offer.callback.data
+          });
+          const offerCollaterals = new Set(
+            offer.collaterals.map((c) => c.asset.toLowerCase())
+          );
+          for (const { collateral } of decoded) {
+            if (!offerCollaterals.has(collateral.toLowerCase())) {
+              return { message: "Sell callback collateral is not part of offer collaterals." };
+            }
+          }
+        } catch (_2) {
+        }
+      }
+    }
+  );
   return [
     chainId,
     loanToken,
     expiry,
-    // note: callback rule should be the last one, since it does not mean that the offer is forever invalid
+    // 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
-    callback
+    sellEmptyCallback,
+    buyNonEmptyCallback,
+    sellNonWhitelistedCallback,
+    sellCallbackDataInvalid,
+    sellCallbackCollateralInvalid
   ];
 }