@morpho-dev/router 0.1.8 → 0.1.10

package/dist/index.node.d.cts

@@ -322,8 +322,10 @@ declare namespace Liquidity$1 {
 }
 
 declare enum CallbackType {
-    BuyWithEmptyCallback = "buy_with_empty_callback"
+    BuyWithEmptyCallback = "buy_with_empty_callback",
+    SellWithdrawFromWallet = "sell_withdraw_from_wallet"
 }
+declare const WhitelistedCallbackAddresses: Record<CallbackType, readonly string[]>;
 declare function buildLiquidity(parameters: {
     type: CallbackType;
     user: string;
@@ -334,13 +336,28 @@ declare function buildLiquidity(parameters: {
     updatedAt?: Date;
 }): Liquidity;
 declare function getCallbackIdForOffer(offer: Offer.Offer): string | null;
+declare function decode$1(parameters: {
+    type: CallbackType;
+    data: Hex;
+}): Array<{
+    collateral: Address;
+    amount: bigint;
+}>;
+declare function encode$1(parameters: {
+    type: CallbackType;
+    data: {
+        collaterals: Address[];
+        amounts: bigint[];
+    };
+}): Hex;
 
 type Callback_CallbackType = CallbackType;
 declare const Callback_CallbackType: typeof CallbackType;
+declare const Callback_WhitelistedCallbackAddresses: typeof WhitelistedCallbackAddresses;
 declare const Callback_buildLiquidity: typeof buildLiquidity;
 declare const Callback_getCallbackIdForOffer: typeof getCallbackIdForOffer;
 declare namespace Callback {
-  export { Callback_CallbackType as CallbackType, Callback_buildLiquidity as buildLiquidity, Callback_getCallbackIdForOffer as getCallbackIdForOffer };
+  export { Callback_CallbackType as CallbackType, Callback_WhitelistedCallbackAddresses as WhitelistedCallbackAddresses, Callback_buildLiquidity as buildLiquidity, decode$1 as decode, encode$1 as encode, Callback_getCallbackIdForOffer as getCallbackIdForOffer };
 }
 
 type PgDB = ReturnType<typeof drizzle> & {
@@ -2068,7 +2085,103 @@ declare function morpho(): (Rule<{
     readonly hash: viem.Hex;
     signature?: viem.Hex;
     createdAt?: number;
-}, "empty_callback", MorphoContext>)[];
+}, "sell_offers_empty_callback", MorphoContext> | Rule<{
+    readonly offering: Address;
+    readonly assets: bigint;
+    readonly rate: bigint;
+    readonly maturity: number & _morpho_dev_mempool.Brand<"Maturity">;
+    readonly expiry: number;
+    readonly nonce: bigint;
+    readonly buy: boolean;
+    readonly chainId: bigint;
+    readonly loanToken: Address;
+    readonly start: number;
+    readonly collaterals: readonly {
+        asset: Address;
+        oracle: Address;
+        lltv: bigint & _morpho_dev_mempool.Brand<"LLTV">;
+    }[];
+    readonly callback: {
+        readonly address: Address;
+        readonly data: viem.Hex;
+        readonly gasLimit: bigint;
+    };
+    readonly hash: viem.Hex;
+    signature?: viem.Hex;
+    createdAt?: number;
+}, "buy_offers_non_empty_callback", MorphoContext> | Rule<{
+    readonly offering: Address;
+    readonly assets: bigint;
+    readonly rate: bigint;
+    readonly maturity: number & _morpho_dev_mempool.Brand<"Maturity">;
+    readonly expiry: number;
+    readonly nonce: bigint;
+    readonly buy: boolean;
+    readonly chainId: bigint;
+    readonly loanToken: Address;
+    readonly start: number;
+    readonly collaterals: readonly {
+        asset: Address;
+        oracle: Address;
+        lltv: bigint & _morpho_dev_mempool.Brand<"LLTV">;
+    }[];
+    readonly callback: {
+        readonly address: Address;
+        readonly data: viem.Hex;
+        readonly gasLimit: bigint;
+    };
+    readonly hash: viem.Hex;
+    signature?: viem.Hex;
+    createdAt?: number;
+}, "sell_offers_non_whitelisted_callback", MorphoContext> | Rule<{
+    readonly offering: Address;
+    readonly assets: bigint;
+    readonly rate: bigint;
+    readonly maturity: number & _morpho_dev_mempool.Brand<"Maturity">;
+    readonly expiry: number;
+    readonly nonce: bigint;
+    readonly buy: boolean;
+    readonly chainId: bigint;
+    readonly loanToken: Address;
+    readonly start: number;
+    readonly collaterals: readonly {
+        asset: Address;
+        oracle: Address;
+        lltv: bigint & _morpho_dev_mempool.Brand<"LLTV">;
+    }[];
+    readonly callback: {
+        readonly address: Address;
+        readonly data: viem.Hex;
+        readonly gasLimit: bigint;
+    };
+    readonly hash: viem.Hex;
+    signature?: viem.Hex;
+    createdAt?: number;
+}, "sell_offers_callback_data_invalid", MorphoContext> | Rule<{
+    readonly offering: Address;
+    readonly assets: bigint;
+    readonly rate: bigint;
+    readonly maturity: number & _morpho_dev_mempool.Brand<"Maturity">;
+    readonly expiry: number;
+    readonly nonce: bigint;
+    readonly buy: boolean;
+    readonly chainId: bigint;
+    readonly loanToken: Address;
+    readonly start: number;
+    readonly collaterals: readonly {
+        asset: Address;
+        oracle: Address;
+        lltv: bigint & _morpho_dev_mempool.Brand<"LLTV">;
+    }[];
+    readonly callback: {
+        readonly address: Address;
+        readonly data: viem.Hex;
+        readonly gasLimit: bigint;
+    };
+    readonly hash: viem.Hex;
+    signature?: viem.Hex;
+    createdAt?: number;
+}, "sell_offers_callback_collateral_invalid", MorphoContext>)[];
 
 type ValidationRule_Batch<T, RuleName extends string, Ctx = void> = Batch<T, RuleName, Ctx>;
 type ValidationRule_MorphoContext = MorphoContext;

package/dist/index.node.d.ts

@@ -322,8 +322,10 @@ declare namespace Liquidity$1 {
 }
 
 declare enum CallbackType {
-    BuyWithEmptyCallback = "buy_with_empty_callback"
+    BuyWithEmptyCallback = "buy_with_empty_callback",
+    SellWithdrawFromWallet = "sell_withdraw_from_wallet"
 }
+declare const WhitelistedCallbackAddresses: Record<CallbackType, readonly string[]>;
 declare function buildLiquidity(parameters: {
     type: CallbackType;
     user: string;
@@ -334,13 +336,28 @@ declare function buildLiquidity(parameters: {
     updatedAt?: Date;
 }): Liquidity;
 declare function getCallbackIdForOffer(offer: Offer.Offer): string | null;
+declare function decode$1(parameters: {
+    type: CallbackType;
+    data: Hex;
+}): Array<{
+    collateral: Address;
+    amount: bigint;
+}>;
+declare function encode$1(parameters: {
+    type: CallbackType;
+    data: {
+        collaterals: Address[];
+        amounts: bigint[];
+    };
+}): Hex;
 
 type Callback_CallbackType = CallbackType;
 declare const Callback_CallbackType: typeof CallbackType;
+declare const Callback_WhitelistedCallbackAddresses: typeof WhitelistedCallbackAddresses;
 declare const Callback_buildLiquidity: typeof buildLiquidity;
 declare const Callback_getCallbackIdForOffer: typeof getCallbackIdForOffer;
 declare namespace Callback {
-  export { Callback_CallbackType as CallbackType, Callback_buildLiquidity as buildLiquidity, Callback_getCallbackIdForOffer as getCallbackIdForOffer };
+  export { Callback_CallbackType as CallbackType, Callback_WhitelistedCallbackAddresses as WhitelistedCallbackAddresses, Callback_buildLiquidity as buildLiquidity, decode$1 as decode, encode$1 as encode, Callback_getCallbackIdForOffer as getCallbackIdForOffer };
 }
 
 type PgDB = ReturnType<typeof drizzle> & {
@@ -2068,7 +2085,103 @@ declare function morpho(): (Rule<{
     readonly hash: viem.Hex;
     signature?: viem.Hex;
     createdAt?: number;
-}, "empty_callback", MorphoContext>)[];
+}, "sell_offers_empty_callback", MorphoContext> | Rule<{
+    readonly offering: Address;
+    readonly assets: bigint;
+    readonly rate: bigint;
+    readonly maturity: number & _morpho_dev_mempool.Brand<"Maturity">;
+    readonly expiry: number;
+    readonly nonce: bigint;
+    readonly buy: boolean;
+    readonly chainId: bigint;
+    readonly loanToken: Address;
+    readonly start: number;
+    readonly collaterals: readonly {
+        asset: Address;
+        oracle: Address;
+        lltv: bigint & _morpho_dev_mempool.Brand<"LLTV">;
+    }[];
+    readonly callback: {
+        readonly address: Address;
+        readonly data: viem.Hex;
+        readonly gasLimit: bigint;
+    };
+    readonly hash: viem.Hex;
+    signature?: viem.Hex;
+    createdAt?: number;
+}, "buy_offers_non_empty_callback", MorphoContext> | Rule<{
+    readonly offering: Address;
+    readonly assets: bigint;
+    readonly rate: bigint;
+    readonly maturity: number & _morpho_dev_mempool.Brand<"Maturity">;
+    readonly expiry: number;
+    readonly nonce: bigint;
+    readonly buy: boolean;
+    readonly chainId: bigint;
+    readonly loanToken: Address;
+    readonly start: number;
+    readonly collaterals: readonly {
+        asset: Address;
+        oracle: Address;
+        lltv: bigint & _morpho_dev_mempool.Brand<"LLTV">;
+    }[];
+    readonly callback: {
+        readonly address: Address;
+        readonly data: viem.Hex;
+        readonly gasLimit: bigint;
+    };
+    readonly hash: viem.Hex;
+    signature?: viem.Hex;
+    createdAt?: number;
+}, "sell_offers_non_whitelisted_callback", MorphoContext> | Rule<{
+    readonly offering: Address;
+    readonly assets: bigint;
+    readonly rate: bigint;
+    readonly maturity: number & _morpho_dev_mempool.Brand<"Maturity">;
+    readonly expiry: number;
+    readonly nonce: bigint;
+    readonly buy: boolean;
+    readonly chainId: bigint;
+    readonly loanToken: Address;
+    readonly start: number;
+    readonly collaterals: readonly {
+        asset: Address;
+        oracle: Address;
+        lltv: bigint & _morpho_dev_mempool.Brand<"LLTV">;
+    }[];
+    readonly callback: {
+        readonly address: Address;
+        readonly data: viem.Hex;
+        readonly gasLimit: bigint;
+    };
+    readonly hash: viem.Hex;
+    signature?: viem.Hex;
+    createdAt?: number;
+}, "sell_offers_callback_data_invalid", MorphoContext> | Rule<{
+    readonly offering: Address;
+    readonly assets: bigint;
+    readonly rate: bigint;
+    readonly maturity: number & _morpho_dev_mempool.Brand<"Maturity">;
+    readonly expiry: number;
+    readonly nonce: bigint;
+    readonly buy: boolean;
+    readonly chainId: bigint;
+    readonly loanToken: Address;
+    readonly start: number;
+    readonly collaterals: readonly {
+        asset: Address;
+        oracle: Address;
+        lltv: bigint & _morpho_dev_mempool.Brand<"LLTV">;
+    }[];
+    readonly callback: {
+        readonly address: Address;
+        readonly data: viem.Hex;
+        readonly gasLimit: bigint;
+    };
+    readonly hash: viem.Hex;
+    signature?: viem.Hex;
+    createdAt?: number;
+}, "sell_offers_callback_collateral_invalid", MorphoContext>)[];
 
 type ValidationRule_Batch<T, RuleName extends string, Ctx = void> = Batch<T, RuleName, Ctx>;
 type ValidationRule_MorphoContext = MorphoContext;

package/dist/index.node.js

@@ -724,13 +724,25 @@ function fromResponse(offerResponse) {
 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["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
+  ]
+};
 function buildLiquidity(parameters) {
   const { type, user, contract, chainId, amount, index: index2 = 0, updatedAt = /* @__PURE__ */ new Date() } = parameters;
   if (type !== "buy_with_empty_callback" /* BuyWithEmptyCallback */)
@@ -772,6 +784,38 @@ function getCallbackIdForOffer(offer) {
   }
   return null;
 }
+function decodeSellWithdrawFromWalletData(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 SellWithdrawFromWallet callback data");
+  }
+}
+function decode2(parameters) {
+  const { type, data } = parameters;
+  if (type === "sell_withdraw_from_wallet" /* SellWithdrawFromWallet */) {
+    return decodeSellWithdrawFromWalletData(data);
+  }
+  throw new Error(`CallbackType not implemented: ${type}`);
+}
+function encode2(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}`);
+}
 
 // src/core/Collector/index.ts
 var Collector_exports = {};
@@ -1391,18 +1435,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 = decode2({
+            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 = decode2({
+            type: "sell_withdraw_from_wallet" /* SellWithdrawFromWallet */,
+            data: offer.callback.data
+          });
+          const offerCollaterals2 = new Set(
+            offer.collaterals.map((c) => c.asset.toLowerCase())
+          );
+          for (const { collateral } of decoded) {
+            if (!offerCollaterals2.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
   ];
 }
 
@@ -1451,9 +1566,11 @@ function createMempoolCollector(parameters) {
           });
           const invalidOffersToSave = [];
           const issueToStatus = {
-            empty_callback: "callback_not_supported",
             sell_offers_empty_callback: "callback_not_supported",
-            buy_offers_empty_callback: "callback_error"
+            buy_offers_non_empty_callback: "callback_not_supported",
+            sell_offers_non_whitelisted_callback: "callback_not_supported",
+            sell_offers_callback_data_invalid: "callback_error",
+            sell_offers_callback_collateral_invalid: "callback_error"
           };
           for (const issue of issues) {
             const status = issueToStatus[issue.ruleName];