@morpho-org/bundler-sdk-viem 2.2.1-next.0 → 3.0.0-next.0

package/lib/operations.js

@@ -1,14 +1,14 @@
 import { DEFAULT_SLIPPAGE_TOLERANCE, MarketUtils, MathLib, NATIVE_ADDRESS, erc20WrapperTokens, getChainAddresses, getUnwrappedToken, permissionedBackedTokens, permissionedWrapperTokens, } from "@morpho-org/blue-sdk";
 import { bigIntComparator, entries, getLast, getValue, keys, } from "@morpho-org/morpho-ts";
 import { handleOperation, handleOperations, produceImmutable, simulateOperation, simulateOperations, } from "@morpho-org/simulation-sdk";
-import { maxUint256 } from "viem";
+import { isAddressEqual, maxUint256 } from "viem";
 import { BundlerErrors } from "./errors.js";
 /**
  * The default target utilization above which the shared liquidity algorithm is triggered (scaled by WAD).
  */
 export const DEFAULT_SUPPLY_TARGET_UTILIZATION = 905000000000000000n;
 export const populateInputTransfer = ({ address, args: { amount, from } }, data, { hasSimplePermit = false } = {}) => {
-    const { bundler, permit2 } = getChainAddresses(data.chainId);
+    const { bundler3: { bundler3, generalAdapter1 }, permit2, } = getChainAddresses(data.chainId);
     // If native token, it is expected to be sent along as call value.
     if (address === NATIVE_ADDRESS)
         return [
@@ -19,22 +19,22 @@ export const populateInputTransfer = ({ address, args: { amount, from } }, data,
                 args: {
                     amount,
                     from,
-                    to: bundler,
+                    to: generalAdapter1,
                 },
             },
         ];
     const { erc20Allowances, permit2BundlerAllowance, erc2612Nonce } = data.getHolding(from, address);
     // ERC20 allowance to the bundler is enough, consume it.
-    if (erc20Allowances.bundler >= amount)
+    if (erc20Allowances["bundler3.generalAdapter1"] >= amount)
         return [
             {
                 type: "Erc20_Transfer",
-                sender: bundler,
+                sender: generalAdapter1,
                 address,
                 args: {
                     amount,
                     from,
-                    to: bundler,
+                    to: generalAdapter1,
                 },
             },
         ];
@@ -52,7 +52,7 @@ export const populateInputTransfer = ({ address, args: { amount, from } }, data,
             address,
             args: {
                 amount,
-                spender: bundler,
+                spender: generalAdapter1,
                 nonce: erc2612Nonce,
             },
         });
@@ -64,18 +64,18 @@ export const populateInputTransfer = ({ address, args: { amount, from } }, data,
             address,
             args: {
                 amount,
-                spender: bundler,
+                spender: generalAdapter1,
             },
         });
     if (useSimplePermit || isPermissioned)
         operations.push({
             type: "Erc20_Transfer",
-            sender: bundler,
+            sender: generalAdapter1,
             address,
             args: {
                 amount,
                 from,
-                to: bundler,
+                to: generalAdapter1,
             },
         });
     // Simple permit is not supported and token is not permissioned: fallback to Permit2.
@@ -104,12 +104,12 @@ export const populateInputTransfer = ({ address, args: { amount, from } }, data,
             });
         operations.push({
             type: "Erc20_Transfer2",
-            sender: bundler,
+            sender: bundler3,
             address,
             args: {
                 amount,
                 from,
-                to: bundler,
+                to: generalAdapter1,
             },
         });
     }
@@ -130,7 +130,7 @@ export const populateInputTransfer = ({ address, args: { amount, from } }, data,
  */
 export const populateSubBundle = (inputOperation, data, options = {}) => {
     const { sender } = inputOperation;
-    const { morpho, bundler } = getChainAddresses(data.chainId);
+    const { morpho, bundler3: { bundler3, generalAdapter1 }, } = getChainAddresses(data.chainId);
     const { withSimplePermit = new Set(), publicAllocatorOptions, getRequirementOperations, } = options;
     const operations = [];
     const wrappedToken = inputOperation.type === "Erc20_Wrap"
@@ -140,7 +140,7 @@ export const populateSubBundle = (inputOperation, data, options = {}) => {
         erc20WrapperTokens[data.chainId].has(wrappedToken.address);
     // Transform input operation to act on behalf of the sender, via the bundler.
     const mainOperation = produceImmutable(inputOperation, (draft) => {
-        draft.sender = bundler;
+        draft.sender = generalAdapter1;
         // Redirect MetaMorpho operation owner.
         switch (draft.type) {
             case "Erc20_Wrap": {
@@ -154,7 +154,7 @@ export const populateSubBundle = (inputOperation, data, options = {}) => {
             case "MetaMorpho_Withdraw":
                 // Only if sender is owner otherwise the owner would be lost.
                 if (draft.args.owner === sender)
-                    draft.args.owner = bundler;
+                    draft.args.owner = generalAdapter1;
         }
         // Redirect operation targets.
         switch (draft.type) {
@@ -165,7 +165,7 @@ export const populateSubBundle = (inputOperation, data, options = {}) => {
             case "MetaMorpho_Withdraw":
                 // Only if sender is receiver otherwise the receiver would be lost.
                 if (draft.args.receiver === sender)
-                    draft.args.receiver = bundler;
+                    draft.args.receiver = generalAdapter1;
         }
     });
     const needsBundlerAuthorization = mainOperation.type === "Blue_Borrow" ||
@@ -174,7 +174,7 @@ export const populateSubBundle = (inputOperation, data, options = {}) => {
     if (needsBundlerAuthorization && !data.getUser(sender).isBundlerAuthorized)
         operations.push({
             type: "Blue_SetAuthorization",
-            sender: bundler,
+            sender: bundler3,
             address: morpho,
             args: {
                 owner: sender,
@@ -238,6 +238,9 @@ export const populateSubBundle = (inputOperation, data, options = {}) => {
                 requiredAssets -= withdrawal.assets;
                 vaultReallocations.push(withdrawal);
             }
+            // TODO: we know there are no unwrap native in the middle
+            // of the bundle so we are certain we need to add an input transfer.
+            // This could be handled by `simulateRequiredTokenAmounts` below.
             const fees = keys(reallocations).reduce((total, vault) => total + data.getVault(vault).publicAllocatorConfig.fee, 0n);
             // Native input transfer of all fees.
             if (fees > 0n)
@@ -248,14 +251,14 @@ export const populateSubBundle = (inputOperation, data, options = {}) => {
                     args: {
                         amount: fees,
                         from: sender,
-                        to: bundler,
+                        to: bundler3,
                     },
                 });
         }
         // Reallocate each vault.
         operations.push(...Object.entries(reallocations).map(([vault, vaultWithdrawals]) => ({
             type: "MetaMorpho_PublicReallocate",
-            sender: bundler,
+            sender: bundler3,
             address: vault,
             args: {
                 // Reallocation withdrawals must be sorted by market id in ascending alphabetical order.
@@ -296,7 +299,7 @@ export const populateSubBundle = (inputOperation, data, options = {}) => {
             mainOperation.args.assets === maxUint256) ||
         ("shares" in mainOperation.args && mainOperation.args.shares === maxUint256)) {
         if (mainOperation.type === "MetaMorpho_Withdraw")
-            mainOperation.args.owner = bundler;
+            mainOperation.args.owner = generalAdapter1;
         return allOperations;
     }
     const requirementOperations = getRequirementOperations?.(requiredTokenAmounts) ?? [];
@@ -307,12 +310,12 @@ export const populateSubBundle = (inputOperation, data, options = {}) => {
     requiredTokenAmounts.forEach(({ token, required }) => {
         requirementOperations.push(...populateInputTransfer({
             type: "Erc20_Transfer",
-            sender: bundler,
+            sender: generalAdapter1,
             address: token,
             args: {
                 amount: required,
                 from: sender,
-                to: bundler,
+                to: generalAdapter1,
             },
         }, data, { hasSimplePermit: withSimplePermit.has(token) }));
     });
@@ -334,8 +337,9 @@ export const finalizeBundle = (operations, startData, receiver, unwrapTokens = n
     const nbOperations = operations.length;
     if (nbOperations === 0)
         return operations;
-    const { bundler } = getChainAddresses(startData.chainId);
-    if (receiver === bundler)
+    const { bundler3: { bundler3, generalAdapter1 }, } = getChainAddresses(startData.chainId);
+    if (isAddressEqual(receiver, bundler3) ||
+        isAddressEqual(receiver, generalAdapter1))
         throw Error(`receiver is bundler`);
     const approvals = [];
     const permits = [];
@@ -387,8 +391,8 @@ export const finalizeBundle = (operations, startData, receiver, unwrapTokens = n
             }
             case "Erc20_Transfer": {
                 const { address, sender, args: { amount, from, to }, } = operation;
-                if (from !== bundler &&
-                    to === bundler &&
+                if (from !== generalAdapter1 &&
+                    to === generalAdapter1 &&
                     !erc20WrapperTokens[startData.chainId].has(address)) {
                     const duplicateTransfer = inputTransfers.find((transfer) => transfer.address === address &&
                         transfer.sender === sender &&
@@ -405,7 +409,7 @@ export const finalizeBundle = (operations, startData, receiver, unwrapTokens = n
             }
             case "Erc20_Transfer2": {
                 const { address, sender, args: { amount, from, to }, } = operation;
-                if (from !== bundler && to === bundler) {
+                if (from !== generalAdapter1 && to === generalAdapter1) {
                     const duplicateTransfer2 = inputTransfer2s.find((transfer) => transfer.address === address &&
                         transfer.sender === sender &&
                         transfer.args.from === from);
@@ -436,15 +440,15 @@ export const finalizeBundle = (operations, startData, receiver, unwrapTokens = n
     // Redirect MetaMorpho deposits.
     operations.forEach((operation, index) => {
         if (operation.type !== "MetaMorpho_Deposit" ||
-            operation.args.owner !== bundler)
+            operation.args.owner !== generalAdapter1)
             return;
         const token = operation.address;
         // shares are not defined when depositing assets, so we rely on simulation steps.
-        const shares = steps[index + 1].getHolding(bundler, token).balance -
-            steps[index].getHolding(bundler, token).balance;
+        const shares = steps[index + 1].getHolding(generalAdapter1, token).balance -
+            steps[index].getHolding(generalAdapter1, token).balance;
         if (steps
             .slice(index + 2)
-            .some((step) => step.getHolding(bundler, token).balance < shares))
+            .some((step) => step.getHolding(generalAdapter1, token).balance < shares))
             // If the bundler's balance is at least once lower than assets, the bundler does need these assets.
             return;
         operation.args.owner = receiver;
@@ -466,14 +470,14 @@ export const finalizeBundle = (operations, startData, receiver, unwrapTokens = n
             default:
                 return;
         }
-        if (operation.args.receiver !== bundler || unwrapTokens.has(token))
+        if (operation.args.receiver !== generalAdapter1 || unwrapTokens.has(token))
             return;
         // assets are not defined when using shares, so we rely on simulation steps.
-        const assets = steps[index + 1].getHolding(bundler, token).balance -
-            steps[index].getHolding(bundler, token).balance;
+        const assets = steps[index + 1].getHolding(generalAdapter1, token).balance -
+            steps[index].getHolding(generalAdapter1, token).balance;
         if (steps
             .slice(index + 2)
-            .some((step) => step.getHolding(bundler, token).balance < assets))
+            .some((step) => step.getHolding(generalAdapter1, token).balance < assets))
             // If the bundler's balance is at least once lower than assets, the bundler does need these assets.
             return;
         operation.args.receiver = receiver;
@@ -481,15 +485,15 @@ export const finalizeBundle = (operations, startData, receiver, unwrapTokens = n
     // Simplify Erc20_Transfer(sender = bundler, to = bundler) + MetaMorpho_Withdraw(owner = bundler) = MetaMorpho_Withdraw(owner = from).
     operations.forEach((operation, index) => {
         if (operation.type !== "MetaMorpho_Withdraw" ||
-            operation.args.owner !== bundler)
+            operation.args.owner !== generalAdapter1)
             return;
         // shares are not defined when using assets, so we rely on simulation steps.
-        const shares = steps[index].getHolding(bundler, operation.address).balance -
-            steps[index + 1].getHolding(bundler, operation.address).balance;
+        const shares = steps[index].getHolding(generalAdapter1, operation.address).balance -
+            steps[index + 1].getHolding(generalAdapter1, operation.address).balance;
         const inputTransferIndex = operations.findIndex((candidate) => candidate.type === "Erc20_Transfer" &&
             candidate.address === operation.address &&
-            candidate.sender === bundler &&
-            candidate.args.to === bundler &&
+            candidate.sender === generalAdapter1 &&
+            candidate.args.to === generalAdapter1 &&
             candidate.args.amount >= shares);
         if (inputTransferIndex <= 0)
             return;
@@ -502,12 +506,12 @@ export const finalizeBundle = (operations, startData, receiver, unwrapTokens = n
         if (operation.type !== "Erc20_Transfer")
             return true;
         const { amount, from, to } = operation.args;
-        if (from === bundler || to !== bundler)
+        if (from === generalAdapter1 || to !== generalAdapter1)
             return true;
         const token = operation.address;
         if (steps
             .slice(index + 2)
-            .some((step) => step.getHolding(bundler, token).balance < amount))
+            .some((step) => step.getHolding(generalAdapter1, token).balance < amount))
             // If the bundler's balance is at least once less than amount, the bundler does need these assets.
             // Do not only keep the amount actually used in this case because some input transfers
             // are expected to be larger to account for slippage.
@@ -518,7 +522,7 @@ export const finalizeBundle = (operations, startData, receiver, unwrapTokens = n
     steps = simulateBundlerOperations(operations, startData, { slippage: 0n });
     // Unwrap requested remaining wrapped tokens.
     const unwraps = [];
-    const endBundlerTokenData = getLast(steps).holdings[bundler] ?? {};
+    const endBundlerTokenData = getLast(steps).holdings[generalAdapter1] ?? {};
     unwrapTokens.forEach((wrappedToken) => {
         const remaining = endBundlerTokenData[wrappedToken]?.balance ?? 0n;
         if (remaining <= 5n)
@@ -529,7 +533,7 @@ export const finalizeBundle = (operations, startData, receiver, unwrapTokens = n
         unwraps.push({
             type: "Erc20_Unwrap",
             address: wrappedToken,
-            sender: bundler,
+            sender: generalAdapter1,
             args: {
                 amount: maxUint256,
                 receiver,
@@ -544,17 +548,19 @@ export const finalizeBundle = (operations, startData, receiver, unwrapTokens = n
     // Skim any token expected to be left on the bundler.
     const skims = [];
     {
-        const startBundlerTokenData = steps[0].holdings[bundler] ?? {};
-        const endBundlerTokenData = getLast(steps).holdings[bundler] ?? {};
+        const startBundlerTokenData = steps[0].holdings[generalAdapter1] ?? {};
+        const endBundlerTokenData = getLast(steps).holdings[generalAdapter1] ?? {};
         skims.push(...entries(endBundlerTokenData)
-            .filter(([token, { balance }]) => balance - (startBundlerTokenData[token]?.balance ?? 0n) > 5n)
+            .filter(([token, holding]) => holding != null &&
+            holding.balance - (startBundlerTokenData[token]?.balance ?? 0n) >
+                5n)
             .map(([address]) => ({
             type: "Erc20_Transfer",
             address,
-            sender: bundler,
+            sender: generalAdapter1,
             args: {
                 amount: maxUint256,
-                from: bundler,
+                from: generalAdapter1,
                 to: receiver,
             },
         })));
@@ -579,15 +585,17 @@ export const populateBundle = (inputOperations, data, options) => {
     return { operations, steps };
 };
 export const simulateRequiredTokenAmounts = (operations, data) => {
-    const { bundler } = getChainAddresses(data.chainId);
+    const { bundler3: { generalAdapter1 }, } = getChainAddresses(data.chainId);
     const virtualBundlerData = produceImmutable(data, (draft) => {
-        Object.values(draft.holdings[bundler] ?? {}).forEach((bundlerTokenData) => {
+        Object.values(draft.holdings[generalAdapter1] ?? {}).forEach((bundlerTokenData) => {
+            if (bundlerTokenData == null)
+                return;
             // Virtual balance to calculate the amount required.
             bundlerTokenData.balance += MathLib.MAX_UINT_160;
         });
     });
     const steps = simulateOperations(operations, virtualBundlerData);
-    const bundlerTokenDiffs = keys(virtualBundlerData.holdings[bundler]).map((token) => ({
+    const bundlerTokenDiffs = keys(virtualBundlerData.holdings[generalAdapter1]).map((token) => ({
         token,
         required: steps
             .map((step) => 
@@ -597,7 +605,7 @@ export const simulateRequiredTokenAmounts = (operations, data) => {
         //              |                   |=> MAX_UINT_160 - (2 * MAX_UINT_160 - y) < 0
         //              |=> MAX_UINT_160 - (MAX_UINT_160 - y - x) > 0
         MathLib.MAX_UINT_160 -
-            (step.holdings[bundler]?.[token]?.balance ?? 0n))
+            (step.holdings[generalAdapter1]?.[token]?.balance ?? 0n))
             .sort(bigIntComparator((required) => required, 
         // Take the highest required amount among all operations.
         "desc"))[0],

package/lib/types/actions.d.ts

@@ -24,54 +24,68 @@ export interface Permit2PermitSingle {
     sigDeadline: bigint;
 }
 export interface ActionArgs {
-    nativeTransfer: [recipient: Address, amount: bigint];
+    nativeTransfer: [owner: Address, recipient: Address, amount: bigint];
     erc20Transfer: [asset: Address, recipient: Address, amount: bigint];
-    erc20TransferFrom: [asset: Address, amount: bigint];
-    erc20WrapperDepositFor: [wrapper: Address, amount: bigint];
-    erc20WrapperWithdrawTo: [wrapper: Address, account: Address, amount: bigint];
+    erc20TransferFrom: [asset: Address, amount: bigint, recipient?: Address];
+    erc20WrapperDepositFor: [
+        wrapper: Address,
+        underlying: Address,
+        amount: bigint
+    ];
+    erc20WrapperWithdrawTo: [wrapper: Address, receiver: Address, amount: bigint];
     permit: [
+        owner: Address,
         asset: Address,
         amount: bigint,
         deadline: bigint,
         signature: Hex | null,
+        spender?: Address,
         skipRevert?: boolean
     ];
     permitDai: [
+        owner: Address,
         nonce: bigint,
         expiry: bigint,
         allowed: boolean,
         signature: Hex | null,
+        spender?: Address,
         skipRevert?: boolean
     ];
     approve2: [
+        owner: Address,
         permitSingle: Permit2PermitSingle,
         signature: Hex | null,
         skipRevert?: boolean
     ];
-    transferFrom2: [asset: Address, amount: bigint];
+    transferFrom2: [
+        asset: Address,
+        owner: Address,
+        amount: bigint,
+        recipient?: Address
+    ];
     erc4626Mint: [
         erc4626: Address,
         shares: bigint,
-        maxAssets: bigint,
+        maxSharePrice: bigint,
         receiver: Address
     ];
     erc4626Deposit: [
         erc4626: Address,
         assets: bigint,
-        minShares: bigint,
+        maxSharePrice: bigint,
         receiver: Address
     ];
     erc4626Withdraw: [
         erc4626: Address,
         assets: bigint,
-        maxShares: bigint,
+        minSharePrice: bigint,
         receiver: Address,
         owner: Address
     ];
     erc4626Redeem: [
         erc4626: Address,
         shares: bigint,
-        minAssets: bigint,
+        minSharePrice: bigint,
         receiver: Address,
         owner: Address
     ];
@@ -128,9 +142,8 @@ export interface ActionArgs {
         receiver: Address
     ];
     reallocateTo: [
-        publicAllocator: Address,
         vault: Address,
-        value: bigint,
+        fee: bigint,
         withdrawals: InputReallocation[],
         supplyMarket: InputMarketParams
     ];
@@ -142,39 +155,72 @@ export interface ActionArgs {
         proof: Hex[],
         skipRevert?: boolean
     ];
-    wrapNative: [amount: bigint];
-    unwrapNative: [amount: bigint];
-    stakeEth: [amount: bigint, minShares: bigint, referral: Address];
-    wrapStEth: [amount: bigint];
-    unwrapStEth: [amount: bigint];
-    aaveV2Repay: [asset: Address, amount: bigint, rateMode?: bigint];
-    aaveV2Withdraw: [asset: Address, amount: bigint];
-    aaveV3Repay: [asset: Address, amount: bigint, rateMode?: bigint];
-    aaveV3Withdraw: [asset: Address, amount: bigint];
-    aaveV3OptimizerRepay: [underlying: Address, amount: bigint];
+    wrapNative: [amount: bigint, recipient?: Address];
+    unwrapNative: [amount: bigint, recipient?: Address];
+    stakeEth: [
+        amount: bigint,
+        minShares: bigint,
+        referral: Address,
+        recipient?: Address
+    ];
+    wrapStEth: [amount: bigint, recipient?: Address];
+    unwrapStEth: [amount: bigint, recipient?: Address];
+    aaveV2Repay: [
+        asset: Address,
+        amount: bigint,
+        onBehalf: Address,
+        rateMode?: bigint
+    ];
+    aaveV2Withdraw: [asset: Address, amount: bigint, recipient?: Address];
+    aaveV3Repay: [
+        asset: Address,
+        amount: bigint,
+        onBehalf: Address,
+        rateMode?: bigint
+    ];
+    aaveV3Withdraw: [asset: Address, amount: bigint, recipient?: Address];
+    aaveV3OptimizerRepay: [
+        underlying: Address,
+        amount: bigint,
+        onBehalf: Address
+    ];
     aaveV3OptimizerWithdraw: [
         underlying: Address,
         amount: bigint,
-        maxIterations: bigint
+        maxIterations: bigint,
+        recipient?: Address
+    ];
+    aaveV3OptimizerWithdrawCollateral: [
+        underlying: Address,
+        amount: bigint,
+        recipient?: Address
     ];
-    aaveV3OptimizerWithdrawCollateral: [underlying: Address, amount: bigint];
     aaveV3OptimizerApproveManagerWithSig: [
+        owner: Address,
         isApproved: boolean,
         nonce: bigint,
         deadline: bigint,
         signature: Hex | null,
+        manager?: Address,
         skipRevert?: boolean
     ];
-    compoundV2Repay: [cToken: Address, amount: bigint];
-    compoundV2Redeem: [cToken: Address, amount: bigint];
-    compoundV3Repay: [instance: Address, amount: bigint];
-    compoundV3WithdrawFrom: [instance: Address, asset: Address, amount: bigint];
+    compoundV2Repay: [cToken: Address, amount: bigint, onBehalf: Address];
+    compoundV2Redeem: [cToken: Address, amount: bigint, recipient?: Address];
+    compoundV3Repay: [instance: Address, amount: bigint, onBehalf: Address];
+    compoundV3WithdrawFrom: [
+        instance: Address,
+        asset: Address,
+        amount: bigint,
+        recipient?: Address
+    ];
     compoundV3AllowBySig: [
         instance: Address,
+        owner: Address,
         isAllowed: boolean,
         nonce: bigint,
         expiry: bigint,
         signature: Hex | null,
+        manager?: Address,
         skipRevert?: boolean
     ];
 }

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@morpho-org/bundler-sdk-viem",
   "description": "Viem-based extension of `@morpho-org/simulation-sdk` that exports utilities to transform simple interactions on Morpho (such as `Blue_Borrow`) and Morpho Vaults (such as `MetaMorpho_Deposit`) into the required bundles (with ERC20 approvals, transfers, etc) to submit to the bundler onchain.",
-  "version": "2.2.1-next.0",
+  "version": "3.0.0-next.0",
   "author": "Morpho Association <contact@morpho.org>",
   "contributors": [
     "Rubilmax <rmilon@gmail.com>"
@@ -20,10 +20,10 @@
   ],
   "peerDependencies": {
     "viem": "^2.0.0",
-    "@morpho-org/blue-sdk": "^2.3.2-next.0",
-    "@morpho-org/morpho-ts": "^2.1.0",
-    "@morpho-org/simulation-sdk": "^2.1.4-next.0",
-    "@morpho-org/blue-sdk-viem": "^2.2.3-next.0"
+    "@morpho-org/blue-sdk": "^3.0.0-next.1",
+    "@morpho-org/blue-sdk-viem": "^3.0.0-next.0",
+    "@morpho-org/simulation-sdk": "^3.0.0-next.0",
+    "@morpho-org/morpho-ts": "^2.1.0"
   },
   "devDependencies": {
     "@tanstack/query-core": "^5.62.16",
@@ -35,13 +35,13 @@
     "typescript": "^5.7.2",
     "viem": "^2.23.0",
     "vitest": "^3.0.5",
-    "@morpho-org/blue-sdk": "^2.3.2-next.0",
-    "@morpho-org/blue-sdk-viem": "^2.2.3-next.0",
-    "@morpho-org/morpho-test": "^2.2.1",
-    "@morpho-org/simulation-sdk": "^2.1.4-next.0",
+    "@morpho-org/blue-sdk": "^3.0.0-next.1",
+    "@morpho-org/blue-sdk-viem": "^3.0.0-next.0",
     "@morpho-org/morpho-ts": "^2.1.0",
-    "@morpho-org/test": "^2.0.6",
-    "@morpho-org/simulation-sdk-wagmi": "^2.0.6-next.0",
+    "@morpho-org/simulation-sdk": "^3.0.0-next.0",
+    "@morpho-org/morpho-test": "^2.2.1",
+    "@morpho-org/test": "^2.0.7-next.0",
+    "@morpho-org/simulation-sdk-wagmi": "^3.0.0-next.0",
     "@morpho-org/test-wagmi": "^2.0.4"
   },
   "scripts": {