@morpho-org/bundler-sdk-viem 3.1.3 → 3.2.0-next.1

package/lib/BundlerAction.d.ts

@@ -1,4 +1,5 @@
 import { ChainId, type InputMarketParams } from "@morpho-org/blue-sdk";
+import type { ParaswapOffsets } from "@morpho-org/simulation-sdk";
 import { type Address, type Hex } from "viem";
 import type { Action, Authorization, InputReallocation, Permit2PermitSingle } from "./types/index.js";
 export interface BundlerCall {
@@ -231,12 +232,12 @@ export declare namespace BundlerAction {
     /**
      * Encodes a call to the GeneralAdapter1 to flash loan from Morpho Blue.
      * @param chainId The chain id for which to encode the call.
-     * @param asset The address of the ERC20 token to flash loan.
-     * @param amount The amount of tokens to flash loan.
+     * @param token The address of the ERC20 token to flash loan.
+     * @param assets The amount of tokens to flash loan.
      * @param callbackCalls The array of calls to execute inside Morpho Blue's `onMorphoFlashLoan` callback.
      * @param skipRevert Whether to allow the transfer to revert without making the whole bundler revert. Defaults to false.
      */
-    function morphoFlashLoan(chainId: ChainId, asset: Address, amount: bigint, callbackCalls: BundlerCall[], skipRevert?: boolean): BundlerCall[];
+    function morphoFlashLoan(chainId: ChainId, token: Address, assets: bigint, callbackCalls: BundlerCall[], skipRevert?: boolean): BundlerCall[];
     /**
      * Encodes a call to trigger a public reallocation on the PublicAllocator.
      * @param chainId The chain id for which to encode the call.
@@ -247,6 +248,44 @@ export declare namespace BundlerAction {
      * @param skipRevert Whether to allow the transfer to revert without making the whole bundler revert. Defaults to false.
      */
     function publicAllocatorReallocateTo(chainId: ChainId, vault: Address, fee: bigint, withdrawals: InputReallocation[], supplyMarketParams: InputMarketParams, skipRevert?: boolean): BundlerCall[];
+    /**
+     * Encodes a call to the ParaswapAdapter to buy an exact amount of tokens via Paraswap.
+     * @param chainId The chain id for which to encode the call.
+     * @param augustus The address of the Augustus router to use.
+     * @param callData The encoded call data to execute.
+     * @param srcToken The address of the source token.
+     * @param dstToken The address of the destination token.
+     * @param offsets The offsets in callData of the exact buy amount (`exactAmount`), maximum sell amount (`limitAmount`) and quoted sell amount (`quotedAmount`).
+     * @param receiver The address to send the tokens to.
+     * @param skipRevert Whether to allow the swap to revert without making the whole bundle revert. Defaults to false.
+     */
+    function paraswapBuy(chainId: ChainId, augustus: Address, callData: Hex, srcToken: Address, dstToken: Address, offsets: ParaswapOffsets, receiver: Address, skipRevert?: boolean): BundlerCall[];
+    /**
+     * Encodes a call to the ParaswapAdapter to sell an exact amount of tokens via Paraswap.
+     * @param chainId The chain id for which to encode the call.
+     * @param augustus The address of the Augustus router to use.
+     * @param callData The encoded call data to execute.
+     * @param srcToken The address of the source token.
+     * @param dstToken The address of the destination token.
+     * @param sellEntireBalance Whether to sell the entire balance of the source token.
+     * @param offsets The offsets in callData of the exact sell amount (`exactAmount`), minimum buy amount (`limitAmount`) and quoted buy amount (`quotedAmount`).
+     * @param receiver The address to send the tokens to.
+     * @param skipRevert Whether to allow the swap to revert without making the whole bundle revert. Defaults to false.
+     */
+    function paraswapSell(chainId: ChainId, augustus: Address, callData: Hex, srcToken: Address, dstToken: Address, sellEntireBalance: boolean, offsets: ParaswapOffsets, receiver: Address, skipRevert?: boolean): BundlerCall[];
+    /**
+     * Encodes a call to the ParaswapAdapter to buy the exact debt of a position via Paraswap.
+     * @param chainId The chain id for which to encode the call.
+     * @param augustus The address of the Augustus router to use.
+     * @param callData The encoded call data to execute.
+     * @param srcToken The address of the source token.
+     * @param marketParams The market params of the market with the debt assets to buy.
+     * @param offsets The offsets in callData of the exact buy amount (`exactAmount`), maximum sell amount (`limitAmount`) and quoted sell amount (`quotedAmount`).
+     * @param onBehalf The address to buy the debt on behalf of.
+     * @param receiver The address to send the tokens to.
+     * @param skipRevert Whether to allow the swap to revert without making the whole bundle revert. Defaults to false.
+     */
+    function paraswapBuyMorphoDebt(chainId: ChainId, augustus: Address, callData: Hex, srcToken: Address, marketParams: InputMarketParams, offsets: ParaswapOffsets, onBehalf: Address, receiver: Address, skipRevert?: boolean): BundlerCall[];
     /**
      * Encodes a call to the Universal Rewards Distributor to claim rewards.
      * @param chainId The chain id for which to encode the call.

package/lib/BundlerAction.js

@@ -119,10 +119,24 @@ var BundlerAction;
             case "morphoWithdrawCollateral": {
                 return BundlerAction.morphoWithdrawCollateral(chainId, ...args);
             }
+            case "morphoFlashLoan": {
+                const [token, assets, onMorphoFlashLoan, skipRevert] = args;
+                return BundlerAction.morphoFlashLoan(chainId, token, assets, onMorphoFlashLoan.flatMap(BundlerAction.encode.bind(null, chainId)), skipRevert);
+            }
             /* PublicAllocator */
             case "reallocateTo": {
                 return BundlerAction.publicAllocatorReallocateTo(chainId, ...args);
             }
+            /* Paraswap */
+            case "paraswapBuy": {
+                return BundlerAction.paraswapBuy(chainId, ...args);
+            }
+            case "paraswapSell": {
+                return BundlerAction.paraswapSell(chainId, ...args);
+            }
+            case "paraswapBuyMorphoDebt": {
+                return BundlerAction.paraswapBuyMorphoDebt(chainId, ...args);
+            }
             /* Universal Rewards Distributor */
             case "urdClaim": {
                 return BundlerAction.urdClaim(...args);
@@ -889,12 +903,12 @@ var BundlerAction;
     /**
      * Encodes a call to the GeneralAdapter1 to flash loan from Morpho Blue.
      * @param chainId The chain id for which to encode the call.
-     * @param asset The address of the ERC20 token to flash loan.
-     * @param amount The amount of tokens to flash loan.
+     * @param token The address of the ERC20 token to flash loan.
+     * @param assets The amount of tokens to flash loan.
      * @param callbackCalls The array of calls to execute inside Morpho Blue's `onMorphoFlashLoan` callback.
      * @param skipRevert Whether to allow the transfer to revert without making the whole bundler revert. Defaults to false.
      */
-    function morphoFlashLoan(chainId, asset, amount, callbackCalls, skipRevert = false) {
+    function morphoFlashLoan(chainId, token, assets, callbackCalls, skipRevert = false) {
         const { bundler3: { generalAdapter1 }, } = (0, blue_sdk_1.getChainAddresses)(chainId);
         const reenter = callbackCalls.length > 0;
         const reenterData = reenter
@@ -906,7 +920,7 @@ var BundlerAction;
                 data: (0, viem_1.encodeFunctionData)({
                     abi: abis_js_1.generalAdapter1Abi,
                     functionName: "morphoFlashLoan",
-                    args: [asset, amount, reenterData],
+                    args: [token, assets, reenterData],
                 }),
                 value: 0n,
                 skipRevert,
@@ -943,6 +957,114 @@ var BundlerAction;
         ];
     }
     BundlerAction.publicAllocatorReallocateTo = publicAllocatorReallocateTo;
+    /**
+     * Encodes a call to the ParaswapAdapter to buy an exact amount of tokens via Paraswap.
+     * @param chainId The chain id for which to encode the call.
+     * @param augustus The address of the Augustus router to use.
+     * @param callData The encoded call data to execute.
+     * @param srcToken The address of the source token.
+     * @param dstToken The address of the destination token.
+     * @param offsets The offsets in callData of the exact buy amount (`exactAmount`), maximum sell amount (`limitAmount`) and quoted sell amount (`quotedAmount`).
+     * @param receiver The address to send the tokens to.
+     * @param skipRevert Whether to allow the swap to revert without making the whole bundle revert. Defaults to false.
+     */
+    function paraswapBuy(chainId, augustus, callData, srcToken, dstToken, offsets, receiver, skipRevert = false) {
+        const { bundler3: { paraswapAdapter }, } = (0, blue_sdk_1.getChainAddresses)(chainId);
+        if (paraswapAdapter == null)
+            throw new errors_js_1.BundlerErrors.UnexpectedAction("paraswapBuy", chainId);
+        return [
+            {
+                to: paraswapAdapter,
+                data: (0, viem_1.encodeFunctionData)({
+                    abi: abis_js_1.paraswapAdapterAbi,
+                    functionName: "buy",
+                    args: [augustus, callData, srcToken, dstToken, 0n, offsets, receiver],
+                }),
+                value: 0n,
+                skipRevert,
+                callbackHash: viem_1.zeroHash,
+            },
+        ];
+    }
+    BundlerAction.paraswapBuy = paraswapBuy;
+    /**
+     * Encodes a call to the ParaswapAdapter to sell an exact amount of tokens via Paraswap.
+     * @param chainId The chain id for which to encode the call.
+     * @param augustus The address of the Augustus router to use.
+     * @param callData The encoded call data to execute.
+     * @param srcToken The address of the source token.
+     * @param dstToken The address of the destination token.
+     * @param sellEntireBalance Whether to sell the entire balance of the source token.
+     * @param offsets The offsets in callData of the exact sell amount (`exactAmount`), minimum buy amount (`limitAmount`) and quoted buy amount (`quotedAmount`).
+     * @param receiver The address to send the tokens to.
+     * @param skipRevert Whether to allow the swap to revert without making the whole bundle revert. Defaults to false.
+     */
+    function paraswapSell(chainId, augustus, callData, srcToken, dstToken, sellEntireBalance, offsets, receiver, skipRevert = false) {
+        const { bundler3: { paraswapAdapter }, } = (0, blue_sdk_1.getChainAddresses)(chainId);
+        if (paraswapAdapter == null)
+            throw new errors_js_1.BundlerErrors.UnexpectedAction("paraswapSell", chainId);
+        return [
+            {
+                to: paraswapAdapter,
+                data: (0, viem_1.encodeFunctionData)({
+                    abi: abis_js_1.paraswapAdapterAbi,
+                    functionName: "sell",
+                    args: [
+                        augustus,
+                        callData,
+                        srcToken,
+                        dstToken,
+                        sellEntireBalance,
+                        offsets,
+                        receiver,
+                    ],
+                }),
+                value: 0n,
+                skipRevert,
+                callbackHash: viem_1.zeroHash,
+            },
+        ];
+    }
+    BundlerAction.paraswapSell = paraswapSell;
+    /**
+     * Encodes a call to the ParaswapAdapter to buy the exact debt of a position via Paraswap.
+     * @param chainId The chain id for which to encode the call.
+     * @param augustus The address of the Augustus router to use.
+     * @param callData The encoded call data to execute.
+     * @param srcToken The address of the source token.
+     * @param marketParams The market params of the market with the debt assets to buy.
+     * @param offsets The offsets in callData of the exact buy amount (`exactAmount`), maximum sell amount (`limitAmount`) and quoted sell amount (`quotedAmount`).
+     * @param onBehalf The address to buy the debt on behalf of.
+     * @param receiver The address to send the tokens to.
+     * @param skipRevert Whether to allow the swap to revert without making the whole bundle revert. Defaults to false.
+     */
+    function paraswapBuyMorphoDebt(chainId, augustus, callData, srcToken, marketParams, offsets, onBehalf, receiver, skipRevert = false) {
+        const { bundler3: { paraswapAdapter }, } = (0, blue_sdk_1.getChainAddresses)(chainId);
+        if (paraswapAdapter == null)
+            throw new errors_js_1.BundlerErrors.UnexpectedAction("paraswapBuyMorphoDebt", chainId);
+        return [
+            {
+                to: paraswapAdapter,
+                data: (0, viem_1.encodeFunctionData)({
+                    abi: abis_js_1.paraswapAdapterAbi,
+                    functionName: "buyMorphoDebt",
+                    args: [
+                        augustus,
+                        callData,
+                        srcToken,
+                        marketParams,
+                        offsets,
+                        onBehalf,
+                        receiver,
+                    ],
+                }),
+                value: 0n,
+                skipRevert,
+                callbackHash: viem_1.zeroHash,
+            },
+        ];
+    }
+    BundlerAction.paraswapBuyMorphoDebt = paraswapBuyMorphoDebt;
     /* Universal Rewards Distributor */
     /**
      * Encodes a call to the Universal Rewards Distributor to claim rewards.

package/lib/actions.js

@@ -70,7 +70,7 @@ const encodeErc20Approval = (token, sender, spender, amount, data) => {
 const encodeOperation = (operation, dataBefore, supportsSignature = true, index = 0) => {
     const { chainId } = dataBefore;
     const deadline = morpho_ts_1.Time.timestamp() + morpho_ts_1.Time.s.from.h(24n);
-    const { morpho, bundler3: { bundler3, generalAdapter1 }, permit2, wNative, dai, wstEth, stEth, } = (0, blue_sdk_1.getChainAddresses)(chainId);
+    const { morpho, bundler3: { bundler3, generalAdapter1, paraswapAdapter }, permit2, wNative, dai, wstEth, stEth, } = (0, blue_sdk_1.getChainAddresses)(chainId);
     const actions = [];
     const requirements = new ActionBundle_js_1.ActionBundleRequirements();
     let callbackBundle;
@@ -81,7 +81,11 @@ const encodeOperation = (operation, dataBefore, supportsSignature = true, index
             ...operation.args,
             ...(callback && {
                 callback: (dataBefore) => {
-                    callbackBundle = encodeBundle(callback, (0, simulation_sdk_1.getCurrent)(dataBefore), supportsSignature);
+                    callbackBundle = encodeBundle(callback.map((callbackOperation) => ({
+                        ...callbackOperation,
+                        // Inside a callback, the sender is forced to be the generalAdapter1.
+                        sender: generalAdapter1,
+                    })), (0, simulation_sdk_1.getCurrent)(dataBefore), supportsSignature);
                     return callback;
                 },
             }),
@@ -93,7 +97,7 @@ const encodeOperation = (operation, dataBefore, supportsSignature = true, index
         requirements.txs.push(...callbackBundle.requirements.txs);
         requirements.signatures.push(...callbackBundle.requirements.signatures);
     }
-    const { sender, address } = operation;
+    const { sender } = operation;
     switch (operation.type) {
         case "Blue_SetAuthorization": {
             const { owner, isAuthorized, authorized } = operation.args;
@@ -127,7 +131,7 @@ const encodeOperation = (operation, dataBefore, supportsSignature = true, index
                         });
                         await (0, viem_1.verifyTypedData)({
                             ...typedData,
-                            address: sender, // Verify against the authorization's owner.
+                            address: owner, // Verify against the authorization's owner.
                             signature,
                         });
                         return (action.args[1] = signature);
@@ -152,18 +156,18 @@ const encodeOperation = (operation, dataBefore, supportsSignature = true, index
         }
         case "Erc20_Approve": {
             // Native token cannot be approved.
-            if (address === blue_sdk_1.NATIVE_ADDRESS)
+            if (operation.address === blue_sdk_1.NATIVE_ADDRESS)
                 break;
             const { amount, spender } = operation.args;
             // Signatures are not supported, skip Permit2 approval.
             if (!supportsSignature && spender === permit2)
                 break;
-            requirements.txs.push(...encodeErc20Approval(address, sender, spender, amount, dataBefore));
+            requirements.txs.push(...encodeErc20Approval(operation.address, sender, spender, amount, dataBefore));
             break;
         }
         case "Erc20_Permit": {
             // Native token cannot be permitted.
-            if (address === blue_sdk_1.NATIVE_ADDRESS)
+            if (operation.address === blue_sdk_1.NATIVE_ADDRESS)
                 break;
             const { amount, spender, nonce } = operation.args;
             // Never permit any other address than the GeneralAdapter1 otherwise
@@ -171,23 +175,17 @@ const encodeOperation = (operation, dataBefore, supportsSignature = true, index
             if (spender !== generalAdapter1)
                 throw new errors_js_1.BundlerErrors.UnexpectedSignature(spender);
             if (supportsSignature) {
-                const action = address === dai
+                const isDai = dai != null && operation.address === dai;
+                const action = isDai
                     ? {
                         type: "permitDai",
-                        args: [
-                            sender,
-                            nonce,
-                            deadline,
-                            true,
-                            null,
-                            operation.skipRevert,
-                        ],
+                        args: [sender, nonce, deadline, true, null, operation.skipRevert],
                     }
                     : {
                         type: "permit",
                         args: [
                             sender,
-                            address,
+                            operation.address,
                             amount,
                             deadline,
                             null,
@@ -195,14 +193,14 @@ const encodeOperation = (operation, dataBefore, supportsSignature = true, index
                         ],
                     };
                 actions.push(action);
-                const tokenData = dataBefore.getToken(address);
+                const tokenData = dataBefore.getToken(operation.address);
                 requirements.signatures.push({
                     action,
                     async sign(client, account = client.account) {
                         let signature = action.args[4];
                         if (signature != null)
                             return signature; // action is already signed
-                        if (address === dai) {
+                        if (isDai) {
                             const typedData = (0, blue_sdk_viem_1.getDaiPermitTypedData)({
                                 owner: sender,
                                 spender,
@@ -245,12 +243,12 @@ const encodeOperation = (operation, dataBefore, supportsSignature = true, index
                 break;
             }
             // Simple permit is not supported, fallback to standard approval.
-            requirements.txs.push(...encodeErc20Approval(address, sender, spender, amount, dataBefore));
+            requirements.txs.push(...encodeErc20Approval(operation.address, sender, spender, amount, dataBefore));
             break;
         }
         case "Erc20_Permit2": {
             // Native token cannot be permitted.
-            if (address === blue_sdk_1.NATIVE_ADDRESS)
+            if (operation.address === blue_sdk_1.NATIVE_ADDRESS)
                 break;
             const { amount, expiration, nonce } = operation.args;
             if (supportsSignature) {
@@ -260,7 +258,7 @@ const encodeOperation = (operation, dataBefore, supportsSignature = true, index
                         sender,
                         {
                             details: {
-                                token: address,
+                                token: operation.address,
                                 amount,
                                 nonce: Number(nonce),
                                 expiration: Number(expiration),
@@ -304,12 +302,12 @@ const encodeOperation = (operation, dataBefore, supportsSignature = true, index
                 break;
             }
             // Signatures are not supported, fallback to standard approval.
-            requirements.txs.push(...encodeErc20Approval(address, sender, generalAdapter1, amount, dataBefore));
+            requirements.txs.push(...encodeErc20Approval(operation.address, sender, generalAdapter1, amount, dataBefore));
             break;
         }
         case "Erc20_Transfer": {
             const { amount, from, to } = operation.args;
-            if (address === blue_sdk_1.NATIVE_ADDRESS) {
+            if (operation.address === blue_sdk_1.NATIVE_ADDRESS) {
                 actions.push({
                     type: "nativeTransfer",
                     args: [from, to, amount, operation.skipRevert],
@@ -320,13 +318,19 @@ const encodeOperation = (operation, dataBefore, supportsSignature = true, index
             if (from === generalAdapter1) {
                 actions.push({
                     type: "erc20Transfer",
-                    args: [address, to, amount, generalAdapter1, operation.skipRevert],
+                    args: [
+                        operation.address,
+                        to,
+                        amount,
+                        generalAdapter1,
+                        operation.skipRevert,
+                    ],
                 });
                 break;
             }
             actions.push({
                 type: "erc20TransferFrom",
-                args: [address, amount, to, operation.skipRevert],
+                args: [operation.address, amount, to, operation.skipRevert],
             });
             break;
         }
@@ -335,31 +339,31 @@ const encodeOperation = (operation, dataBefore, supportsSignature = true, index
             if (supportsSignature) {
                 actions.push({
                     type: "transferFrom2",
-                    args: [address, amount, to, operation.skipRevert],
+                    args: [operation.address, amount, to, operation.skipRevert],
                 });
                 break;
             }
             // Signatures are not supported, fallback to standard transfer.
             actions.push({
                 type: "erc20TransferFrom",
-                args: [address, amount, to, operation.skipRevert],
+                args: [operation.address, amount, to, operation.skipRevert],
             });
             break;
         }
         case "Erc20_Wrap": {
-            const { amount } = operation.args;
-            switch (address) {
+            const { amount, owner } = operation.args;
+            switch (operation.address) {
                 case wNative: {
                     actions.push({
                         type: "wrapNative",
-                        args: [amount, generalAdapter1, operation.skipRevert],
+                        args: [amount, owner, operation.skipRevert],
                     });
                     break;
                 }
                 case wstEth: {
                     actions.push({
                         type: "wrapStEth",
-                        args: [amount, generalAdapter1, operation.skipRevert],
+                        args: [amount, owner, operation.skipRevert],
                     });
                     break;
                 }
@@ -370,53 +374,58 @@ const encodeOperation = (operation, dataBefore, supportsSignature = true, index
                             amount,
                             blue_sdk_1.MathLib.MAX_UINT_256,
                             viem_1.zeroAddress,
-                            generalAdapter1,
+                            owner,
                             operation.skipRevert,
                         ],
                     });
                     break;
                 }
                 default: {
-                    if (blue_sdk_1.erc20WrapperTokens[chainId]?.has(address)) {
-                        const underlying = (0, blue_sdk_1.getUnwrappedToken)(address, chainId);
+                    if (blue_sdk_1.erc20WrapperTokens[chainId]?.has(operation.address)) {
+                        const underlying = (0, blue_sdk_1.getUnwrappedToken)(operation.address, chainId);
                         if (underlying == null)
-                            throw Error(`unknown wrapped token: ${address}`);
+                            throw Error(`unknown wrapped token: ${operation.address}`);
                         actions.push({
                             type: "erc20WrapperDepositFor",
-                            args: [address, underlying, amount, operation.skipRevert],
+                            args: [
+                                operation.address,
+                                underlying,
+                                amount,
+                                operation.skipRevert,
+                            ],
                         });
                         break;
                     }
                     // Convex token wrapping is executed onchain along with supplyCollateral, via depositFor.
-                    if (!blue_sdk_1.convexWrapperTokens[chainId]?.has(address))
-                        throw Error(`unexpected token wrap: ${address}`);
+                    if (!blue_sdk_1.convexWrapperTokens[chainId]?.has(operation.address))
+                        throw Error(`unexpected token wrap: ${operation.address}`);
                 }
             }
             break;
         }
         case "Erc20_Unwrap": {
             const { amount, receiver } = operation.args;
-            switch (address) {
+            switch (operation.address) {
                 case wNative: {
                     actions.push({
                         type: "unwrapNative",
-                        args: [amount, generalAdapter1, operation.skipRevert],
+                        args: [amount, receiver, operation.skipRevert],
                     });
                     break;
                 }
                 case wstEth: {
                     actions.push({
                         type: "unwrapStEth",
-                        args: [amount, generalAdapter1, operation.skipRevert],
+                        args: [amount, receiver, operation.skipRevert],
                     });
                     break;
                 }
                 default: {
-                    if (!blue_sdk_1.erc20WrapperTokens[chainId]?.has(address))
-                        throw Error(`unexpected token unwrap: ${address}`);
+                    if (!blue_sdk_1.erc20WrapperTokens[chainId]?.has(operation.address))
+                        throw Error(`unexpected token unwrap: ${operation.address}`);
                     actions.push({
                         type: "erc20WrapperWithdrawTo",
-                        args: [address, receiver, amount, operation.skipRevert],
+                        args: [operation.address, receiver, amount, operation.skipRevert],
                     });
                 }
             }
@@ -512,9 +521,9 @@ const encodeOperation = (operation, dataBefore, supportsSignature = true, index
             const { id, assets, onBehalf } = operation.args;
             const { params } = dataBefore.getMarket(id);
             if (blue_sdk_1.convexWrapperTokens[chainId]?.has(params.collateralToken)) {
-                const underlying = (0, blue_sdk_1.getUnwrappedToken)(address, chainId);
+                const underlying = (0, blue_sdk_1.getUnwrappedToken)(params.collateralToken, chainId);
                 if (underlying == null)
-                    throw Error(`unknown wrapped token: ${address}`);
+                    throw Error(`unknown wrapped token: ${params.collateralToken}`);
                 actions.push({
                     type: "erc20WrapperDepositFor",
                     args: [
@@ -551,20 +560,32 @@ const encodeOperation = (operation, dataBefore, supportsSignature = true, index
             const { assets = 0n, shares = 0n, owner, slippage = blue_sdk_1.DEFAULT_SLIPPAGE_TOLERANCE, } = operation.args;
             // Accrue interest to calculate the expected share price.
             const vault = dataBefore
-                .getAccrualVault(address)
+                .getAccrualVault(operation.address)
                 .accrueInterest(dataBefore.block.timestamp);
             if (shares === 0n) {
                 const maxSharePrice = blue_sdk_1.MathLib.mulDivUp(assets, blue_sdk_1.MathLib.wToRay(blue_sdk_1.MathLib.WAD + slippage), vault.toShares(assets));
                 actions.push({
                     type: "erc4626Deposit",
-                    args: [address, assets, maxSharePrice, owner, operation.skipRevert],
+                    args: [
+                        operation.address,
+                        assets,
+                        maxSharePrice,
+                        owner,
+                        operation.skipRevert,
+                    ],
                 });
             }
             else {
                 const maxSharePrice = blue_sdk_1.MathLib.mulDivUp(vault.toAssets(shares), blue_sdk_1.MathLib.wToRay(blue_sdk_1.MathLib.WAD + slippage), shares);
                 actions.push({
                     type: "erc4626Mint",
-                    args: [address, shares, maxSharePrice, owner, operation.skipRevert],
+                    args: [
+                        operation.address,
+                        shares,
+                        maxSharePrice,
+                        owner,
+                        operation.skipRevert,
+                    ],
                 });
             }
             break;
@@ -573,14 +594,14 @@ const encodeOperation = (operation, dataBefore, supportsSignature = true, index
             const { assets = 0n, shares = 0n, owner, receiver, slippage = blue_sdk_1.DEFAULT_SLIPPAGE_TOLERANCE, } = operation.args;
             // Accrue interest to calculate the expected share price.
             const vault = dataBefore
-                .getAccrualVault(address)
+                .getAccrualVault(operation.address)
                 .accrueInterest(dataBefore.block.timestamp);
             if (shares === 0n) {
                 const minSharePrice = blue_sdk_1.MathLib.mulDivUp(assets, blue_sdk_1.MathLib.wToRay(blue_sdk_1.MathLib.WAD - slippage), vault.toShares(assets));
                 actions.push({
                     type: "erc4626Withdraw",
                     args: [
-                        address,
+                        operation.address,
                         assets,
                         minSharePrice,
                         receiver,
@@ -594,7 +615,7 @@ const encodeOperation = (operation, dataBefore, supportsSignature = true, index
                 actions.push({
                     type: "erc4626Redeem",
                     args: [
-                        address,
+                        operation.address,
                         shares,
                         minSharePrice,
                         receiver,
@@ -607,12 +628,13 @@ const encodeOperation = (operation, dataBefore, supportsSignature = true, index
         }
         case "MetaMorpho_PublicReallocate": {
             const { withdrawals, supplyMarketId } = operation.args;
-            const { fee } = dataBefore.getVault(address).publicAllocatorConfig;
+            const { fee } = dataBefore.getVault(operation.address)
+                .publicAllocatorConfig;
             // Value is already accrued via another native input transfer.
             actions.push({
                 type: "reallocateTo",
                 args: [
-                    address,
+                    operation.address,
                     fee,
                     withdrawals.map(({ id, assets }) => ({
                         marketParams: dataBefore.getMarket(id).params,
@@ -624,6 +646,142 @@ const encodeOperation = (operation, dataBefore, supportsSignature = true, index
             });
             break;
         }
+        case "Blue_FlashLoan": {
+            const { token, assets } = operation.args;
+            actions.push({
+                type: "morphoFlashLoan",
+                args: [
+                    token,
+                    assets,
+                    callbackBundle?.actions ?? [],
+                    operation.skipRevert,
+                ],
+            });
+            break;
+        }
+        case "Paraswap_Buy": {
+            if (!("swap" in operation.args))
+                throw new errors_js_1.BundlerErrors.MissingSwapData();
+            if (paraswapAdapter == null)
+                throw new errors_js_1.BundlerErrors.UnexpectedAction("paraswapBuy", chainId);
+            const { srcToken, swap, receiver } = operation.args;
+            const limitAmountOffset = Number(swap.offsets.limitAmount);
+            const limitAmount = (0, viem_1.hexToBigInt)((0, viem_1.slice)(swap.data, limitAmountOffset, limitAmountOffset + 32));
+            actions.push({
+                type: "erc20Transfer",
+                args: [
+                    srcToken,
+                    paraswapAdapter,
+                    limitAmount,
+                    generalAdapter1,
+                    operation.skipRevert,
+                ],
+            }, {
+                type: "paraswapBuy",
+                args: [
+                    swap.to,
+                    swap.data,
+                    srcToken,
+                    operation.address,
+                    swap.offsets,
+                    receiver === paraswapAdapter ? generalAdapter1 : receiver,
+                    operation.skipRevert,
+                ],
+            }, {
+                type: "erc20Transfer",
+                args: [
+                    srcToken,
+                    generalAdapter1,
+                    viem_1.maxUint256,
+                    paraswapAdapter,
+                    operation.skipRevert,
+                ],
+            });
+            break;
+        }
+        case "Paraswap_Sell": {
+            if (!("swap" in operation.args))
+                throw new errors_js_1.BundlerErrors.MissingSwapData();
+            if (paraswapAdapter == null)
+                throw new errors_js_1.BundlerErrors.UnexpectedAction("paraswapBuy", chainId);
+            const { dstToken, swap, sellEntireBalance = false, receiver, } = operation.args;
+            const exactAmountOffset = Number(swap.offsets.exactAmount);
+            const exactAmount = (0, viem_1.hexToBigInt)((0, viem_1.slice)(swap.data, exactAmountOffset, exactAmountOffset + 32));
+            actions.push({
+                type: "erc20Transfer",
+                args: [
+                    operation.address,
+                    paraswapAdapter,
+                    sellEntireBalance ? viem_1.maxUint256 : exactAmount,
+                    generalAdapter1,
+                    operation.skipRevert,
+                ],
+            }, {
+                type: "paraswapSell",
+                args: [
+                    swap.to,
+                    swap.data,
+                    operation.address,
+                    dstToken,
+                    sellEntireBalance,
+                    swap.offsets,
+                    receiver === paraswapAdapter ? generalAdapter1 : receiver,
+                    operation.skipRevert,
+                ],
+            });
+            if (!sellEntireBalance)
+                actions.push({
+                    type: "erc20Transfer",
+                    args: [
+                        operation.address,
+                        generalAdapter1,
+                        viem_1.maxUint256,
+                        paraswapAdapter,
+                        operation.skipRevert,
+                    ],
+                });
+            break;
+        }
+        case "Blue_Paraswap_BuyDebt": {
+            if (!("swap" in operation.args))
+                throw new errors_js_1.BundlerErrors.MissingSwapData();
+            if (paraswapAdapter == null)
+                throw new errors_js_1.BundlerErrors.UnexpectedAction("paraswapBuy", chainId);
+            const { srcToken, id, swap, onBehalf, receiver } = operation.args;
+            const { params } = dataBefore.getMarket(id);
+            actions.push({
+                type: "erc20Transfer",
+                args: [
+                    srcToken,
+                    paraswapAdapter,
+                    viem_1.maxUint256,
+                    generalAdapter1,
+                    operation.skipRevert,
+                ],
+            }, {
+                type: "paraswapBuyMorphoDebt",
+                args: [
+                    swap.to,
+                    swap.data,
+                    srcToken,
+                    params,
+                    swap.offsets,
+                    onBehalf,
+                    receiver === paraswapAdapter ? generalAdapter1 : receiver,
+                    operation.skipRevert,
+                ],
+            }, {
+                type: "erc20Transfer",
+                args: [
+                    srcToken,
+                    generalAdapter1,
+                    viem_1.maxUint256,
+                    paraswapAdapter,
+                    operation.skipRevert,
+                ],
+            });
+            break;
+        }
     }
     return {
         dataAfter,

package/lib/errors.d.ts

@@ -12,6 +12,9 @@ export declare namespace BundlerErrors {
     class MissingSignature extends Error {
         constructor();
     }
+    class MissingSwapData extends Error {
+        constructor();
+    }
     class UnexpectedAction extends Error {
         constructor(type: ActionType, chainId: number);
     }

package/lib/errors.js

@@ -24,6 +24,12 @@ var BundlerErrors;
         }
     }
     BundlerErrors.MissingSignature = MissingSignature;
+    class MissingSwapData extends Error {
+        constructor() {
+            super(`missing swap data`);
+        }
+    }
+    BundlerErrors.MissingSwapData = MissingSwapData;
     class UnexpectedAction extends Error {
         constructor(type, chainId) {
             super(`unexpected action "${type}" on chain "${chainId}"`);

package/lib/operations.d.ts

@@ -61,7 +61,7 @@ export declare const simulateRequiredTokenAmounts: (operations: Operation[], dat
     token: `0x${string}`;
     required: bigint;
 }[];
-export declare const getSimulatedBundlerOperation: (operation: BundlerOperation, { slippage }?: {
+export declare const getSimulatedBundlerOperation: (operation: Omit<BundlerOperation, "sender">, { slippage }?: {
     slippage?: bigint;
 }) => Operation;
 export declare const handleBundlerOperation: (options?: {

package/lib/operations.js

@@ -135,7 +135,7 @@ exports.populateInputTransfer = populateInputTransfer;
  */
 const populateSubBundle = (inputOperation, data, options = {}) => {
     const { sender } = inputOperation;
-    const { morpho, bundler3: { bundler3, generalAdapter1 }, } = (0, blue_sdk_1.getChainAddresses)(data.chainId);
+    const { bundler3: { bundler3, generalAdapter1 }, } = (0, blue_sdk_1.getChainAddresses)(data.chainId);
     const { withSimplePermit = new Set(), publicAllocatorOptions, getRequirementOperations, } = options;
     const operations = [];
     const wrappedToken = inputOperation.type === "Erc20_Wrap"
@@ -143,50 +143,53 @@ const populateSubBundle = (inputOperation, data, options = {}) => {
         : undefined;
     const isErc20Wrapper = !!wrappedToken &&
         !!blue_sdk_1.erc20WrapperTokens[data.chainId]?.has(wrappedToken.address);
-    // Transform input operation to act on behalf of the sender, via the bundler.
     const mainOperation = (0, simulation_sdk_1.produceImmutable)(inputOperation, (draft) => {
-        draft.sender = generalAdapter1;
-        // Redirect MetaMorpho operation owner.
-        switch (draft.type) {
-            case "Erc20_Wrap": {
-                // ERC20Wrapper are skipped because tokens are sent to the caller, not the bundler.
-                if (isErc20Wrapper) {
-                    draft.args.owner = sender;
-                    break;
-                }
+        if (draft.type === "Erc20_Wrap" && isErc20Wrapper)
+            // ERC20Wrapper wrapped tokens are sent to the caller, not the bundler.
+            draft.args.owner = sender;
+        // Transform input operation to act on behalf of the sender, when sender is not the bundler.
+        if (sender !== generalAdapter1) {
+            draft.sender = generalAdapter1;
+            // Redirect MetaMorpho operation owner.
+            switch (draft.type) {
+                case "MetaMorpho_Deposit":
+                case "MetaMorpho_Withdraw":
+                    // Only if sender is owner otherwise the owner would be lost.
+                    if (draft.args.owner === sender)
+                        draft.args.owner = generalAdapter1;
+            }
+            // Redirect operation targets.
+            switch (draft.type) {
+                case "Blue_Borrow":
+                case "Blue_Withdraw":
+                case "Blue_WithdrawCollateral":
+                    draft.args.onBehalf = sender;
+                case "MetaMorpho_Withdraw":
+                case "Paraswap_Buy":
+                case "Paraswap_Sell":
+                case "Blue_Paraswap_BuyDebt":
+                    // Only if sender is receiver otherwise the receiver would be lost.
+                    if (draft.args.receiver === sender)
+                        draft.args.receiver = generalAdapter1;
             }
-            case "MetaMorpho_Deposit":
-            case "MetaMorpho_Withdraw":
-                // Only if sender is owner otherwise the owner would be lost.
-                if (draft.args.owner === sender)
-                    draft.args.owner = generalAdapter1;
-        }
-        // Redirect operation targets.
-        switch (draft.type) {
-            case "Blue_Borrow":
-            case "Blue_Withdraw":
-            case "Blue_WithdrawCollateral":
-                draft.args.onBehalf = sender;
-            case "MetaMorpho_Withdraw":
-                // Only if sender is receiver otherwise the receiver would be lost.
-                if (draft.args.receiver === sender)
-                    draft.args.receiver = generalAdapter1;
         }
     });
-    const needsBundlerAuthorization = mainOperation.type === "Blue_Borrow" ||
+    if (mainOperation.type === "Blue_Borrow" ||
         mainOperation.type === "Blue_Withdraw" ||
-        mainOperation.type === "Blue_WithdrawCollateral";
-    if (needsBundlerAuthorization && !data.getUser(sender).isBundlerAuthorized)
-        operations.push({
-            type: "Blue_SetAuthorization",
-            sender: bundler3,
-            address: morpho,
-            args: {
-                owner: sender,
-                isAuthorized: true,
-                authorized: generalAdapter1,
-            },
-        });
+        mainOperation.type === "Blue_WithdrawCollateral") {
+        // Either sender === generalAdapter1 or sender === onBehalf.
+        const { onBehalf } = mainOperation.args;
+        if (!data.getUser(onBehalf).isBundlerAuthorized)
+            operations.push({
+                type: "Blue_SetAuthorization",
+                sender: bundler3,
+                args: {
+                    owner: onBehalf,
+                    isAuthorized: true,
+                    authorized: generalAdapter1,
+                },
+            });
+    }
     // Reallocate liquidity if necessary.
     if (!!publicAllocatorOptions?.enabled &&
         (mainOperation.type === "Blue_Borrow" ||
@@ -284,7 +287,11 @@ const populateSubBundle = (inputOperation, data, options = {}) => {
             ...(callback && {
                 callback: (data) => {
                     const operations = callback.flatMap((inputOperation) => {
-                        const subBundleOperations = (0, exports.populateSubBundle)(inputOperation, data, options);
+                        const subBundleOperations = (0, exports.populateSubBundle)({
+                            ...inputOperation,
+                            // Inside a callback, the sender is forced to be the generalAdapter1.
+                            sender: generalAdapter1,
+                        }, data, options);
                         // Handle to mutate data (not simulate).
                         (0, exports.handleBundlerOperations)(subBundleOperations, data);
                         return subBundleOperations;
@@ -296,9 +303,13 @@ const populateSubBundle = (inputOperation, data, options = {}) => {
             }),
         },
     };
-    // Operations with callbacks are populated recursively as a side-effect of the simulation, within the callback itself.
-    let requiredTokenAmounts = (0, exports.simulateRequiredTokenAmounts)(operations.concat([simulatedOperation]), data);
+    let requiredTokenAmounts = (0, exports.simulateRequiredTokenAmounts)(
+    // Safe cast because operations do not contain callbacks.
+    operations.concat([simulatedOperation]), data);
+    // Safe cast because operations do not contain callbacks.
     const allOperations = operations.concat([
+        // Safe cast because mainOperation, if including a callback, was transformed to a BundlerOperation
+        // within the callback executed through the simulation `simulateRequiredTokenAmounts`.
         mainOperation,
     ]);
     // Skip approvals/transfers if operation only uses available balances (via maxUint256).
@@ -654,6 +665,9 @@ const getSimulatedBundlerOperation = (operation, { slippage } = {}) => {
             case "Blue_Repay":
             case "MetaMorpho_Deposit":
             case "MetaMorpho_Withdraw":
+            case "Paraswap_Buy":
+            case "Paraswap_Sell":
+            case "Blue_Paraswap_BuyDebt":
                 simulatedOperation.args.slippage = slippage;
                 break;
         }

package/lib/types/actions.d.ts

@@ -1,5 +1,6 @@
 import type { Account, Chain, Client, Hex, TransactionRequest, Transport } from "viem";
 import type { Address, InputMarketParams } from "@morpho-org/blue-sdk";
+import type { ParaswapOffsets } from "@morpho-org/simulation-sdk";
 export interface Authorization {
     authorizer: Address;
     authorized: Address;
@@ -163,6 +164,12 @@ export interface ActionArgs {
         receiver: Address,
         skipRevert?: boolean
     ];
+    morphoFlashLoan: [
+        token: Address,
+        assets: bigint,
+        onMorphoFlashLoan: Action[],
+        skipRevert?: boolean
+    ];
     reallocateTo: [
         vault: Address,
         fee: bigint,
@@ -170,6 +177,35 @@ export interface ActionArgs {
         supplyMarket: InputMarketParams,
         skipRevert?: boolean
     ];
+    paraswapBuy: [
+        augustus: Address,
+        callData: Hex,
+        srcToken: Address,
+        dstToken: Address,
+        offsets: ParaswapOffsets,
+        receiver: Address,
+        skipRevert?: boolean
+    ];
+    paraswapSell: [
+        augustus: Address,
+        callData: Hex,
+        srcToken: Address,
+        dstToken: Address,
+        sellEntireBalance: boolean,
+        offsets: ParaswapOffsets,
+        receiver: Address,
+        skipRevert?: boolean
+    ];
+    paraswapBuyMorphoDebt: [
+        augustus: Address,
+        callData: Hex,
+        srcToken: Address,
+        marketParams: InputMarketParams,
+        offsets: ParaswapOffsets,
+        onBehalf: Address,
+        receiver: Address,
+        skipRevert?: boolean
+    ];
     urdClaim: [
         distributor: Address,
         account: Address,

package/lib/types/operations.d.ts

@@ -1,53 +1,77 @@
-import type { BlueOperationArgs, CALLBACK_OPERATIONS, Erc20OperationArgs, MetaMorphoOperationArgs, OperationArgs, OperationType, WithOperationArgs } from "@morpho-org/simulation-sdk";
-export declare const BUNDLER_OPERATIONS: readonly ["Blue_SetAuthorization", "Blue_Borrow", "Blue_Repay", "Blue_Supply", "Blue_SupplyCollateral", "Blue_Withdraw", "Blue_WithdrawCollateral", "MetaMorpho_Deposit", "MetaMorpho_Withdraw", "MetaMorpho_PublicReallocate", "Erc20_Approve", "Erc20_Permit", "Erc20_Permit2", "Erc20_Transfer", "Erc20_Transfer2", "Erc20_Wrap", "Erc20_Unwrap"];
-export type BundlerOperationType = (typeof BUNDLER_OPERATIONS)[number];
-export interface BundlerOperationArgs extends Omit<OperationArgs, (typeof CALLBACK_OPERATIONS)[number]> {
-    Blue_SupplyCollateral: Omit<BlueOperationArgs["Blue_SupplyCollateral"], "callback"> & {
-        callback?: BundlerOperation[];
+import { type BlueOperationArgs, CALLBACK_OPERATIONS, type CallbackOperationType, type Erc20OperationArgs, type MetaMorphoOperationArgs, type OperationArgs, type OperationType, type ParaswapOperationArgs, type WithOperationArgs } from "@morpho-org/simulation-sdk";
+import type { UnionOmit } from "viem";
+export declare const BLUE_BUNDLER_OPERATIONS: readonly ["Blue_SetAuthorization", "Blue_Borrow", "Blue_Repay", "Blue_Supply", "Blue_SupplyCollateral", "Blue_Withdraw", "Blue_WithdrawCollateral", "Blue_FlashLoan", "Blue_Paraswap_BuyDebt"];
+export type BlueBundlerOperationType = (typeof BLUE_BUNDLER_OPERATIONS)[number];
+export type BlueBundlerOperationArgs = Omit<BlueOperationArgs, (typeof CALLBACK_OPERATIONS)[number]> & {
+    [OperationType in CallbackOperationType]: Omit<BlueOperationArgs[OperationType], "callback"> & {
+        /**
+         * Inside a callback, the sender is forced to be the generalAdapter1.
+         */
+        callback?: UnionOmit<BundlerOperation, "sender">[];
     };
-    Blue_Supply: Omit<BlueOperationArgs["Blue_Supply"], "callback"> & {
-        callback?: BundlerOperation[];
-    };
-    Blue_Repay: Omit<BlueOperationArgs["Blue_Repay"], "callback"> & {
-        callback?: BundlerOperation[];
-    };
-}
-export type BundlerOperations = {
-    [OperationType in BundlerOperationType]: WithOperationArgs<OperationType, BundlerOperationArgs>;
 };
-export type BundlerOperation = BundlerOperations[BundlerOperationType];
-export type CallbackBundlerOperationType = (typeof CALLBACK_OPERATIONS)[number];
-export type CallbackBundlerOperations = {
-    [OperationType in CallbackBundlerOperationType]: WithOperationArgs<OperationType, BundlerOperationArgs>;
+export type BlueBundlerOperations = {
+    [OperationType in BlueBundlerOperationType]: Omit<WithOperationArgs<OperationType, BlueBundlerOperationArgs>, "address">;
+};
+export type BlueBundlerOperation = BlueBundlerOperations[BlueBundlerOperationType];
+export declare const METAMORPHO_BUNDLER_OPERATIONS: readonly ["MetaMorpho_Deposit", "MetaMorpho_Withdraw", "MetaMorpho_PublicReallocate"];
+export type MetaMorphoBundlerOperationType = (typeof METAMORPHO_BUNDLER_OPERATIONS)[number];
+export type MetaMorphoBundlerOperations = {
+    [OperationType in MetaMorphoBundlerOperationType]: WithOperationArgs<OperationType, MetaMorphoOperationArgs>;
+};
+export type MetaMorphoBundlerOperation = MetaMorphoBundlerOperations[MetaMorphoBundlerOperationType];
+export declare const PARASWAP_BUNDLER_OPERATIONS: readonly ["Paraswap_Buy", "Paraswap_Sell"];
+export type ParaswapBundlerOperationType = (typeof PARASWAP_BUNDLER_OPERATIONS)[number];
+export type ParaswapBundlerOperations = {
+    [OperationType in ParaswapBundlerOperationType]: WithOperationArgs<OperationType, ParaswapOperationArgs>;
+};
+export type ParaswapBundlerOperation = ParaswapBundlerOperations[ParaswapBundlerOperationType];
+export declare const ERC20_BUNDLER_OPERATIONS: readonly ["Erc20_Approve", "Erc20_Permit", "Erc20_Permit2", "Erc20_Transfer", "Erc20_Transfer2", "Erc20_Wrap", "Erc20_Unwrap"];
+export type Erc20BundlerOperationType = (typeof ERC20_BUNDLER_OPERATIONS)[number];
+export type Erc20BundlerOperations = {
+    [OperationType in Erc20BundlerOperationType]: WithOperationArgs<OperationType, Erc20OperationArgs>;
 };
+export type Erc20BundlerOperation = Erc20BundlerOperations[Erc20BundlerOperationType];
+export interface BundlerOperationArgs extends BlueOperationArgs, MetaMorphoOperationArgs, ParaswapOperationArgs, Erc20OperationArgs {
+}
+export type BundlerOperations = BlueBundlerOperations & MetaMorphoBundlerOperations & ParaswapBundlerOperations & Erc20BundlerOperations;
+export type BundlerOperationType = BlueBundlerOperationType | MetaMorphoBundlerOperationType | ParaswapBundlerOperationType | Erc20BundlerOperationType;
+export type BundlerOperation = BlueBundlerOperation | MetaMorphoBundlerOperation | ParaswapBundlerOperation | Erc20BundlerOperation;
+export declare const BUNDLER_OPERATIONS: readonly ["Blue_SetAuthorization", "Blue_Borrow", "Blue_Repay", "Blue_Supply", "Blue_SupplyCollateral", "Blue_Withdraw", "Blue_WithdrawCollateral", "Blue_FlashLoan", "Blue_Paraswap_BuyDebt", "MetaMorpho_Deposit", "MetaMorpho_Withdraw", "MetaMorpho_PublicReallocate", "Erc20_Approve", "Erc20_Permit", "Erc20_Permit2", "Erc20_Transfer", "Erc20_Transfer2", "Erc20_Wrap", "Erc20_Unwrap"];
+export type CallbackBundlerOperationType = (typeof CALLBACK_OPERATIONS)[number];
+export type CallbackBundlerOperations = Pick<BundlerOperations, CallbackBundlerOperationType>;
 export type CallbackBundlerOperation = CallbackBundlerOperations[CallbackBundlerOperationType];
-export declare const BLUE_INPUT_OPERATIONS: readonly ["Blue_Borrow", "Blue_Repay", "Blue_Supply", "Blue_SupplyCollateral", "Blue_Withdraw", "Blue_WithdrawCollateral", "Blue_SetAuthorization"];
+export declare const isBlueBundlerOperation: (operation: BundlerOperation) => operation is BlueBundlerOperation;
+export declare const isMetaMorphoBundlerOperation: (operation: BundlerOperation) => operation is MetaMorphoBundlerOperation;
+export declare const isErc20BundlerOperation: (operation: BundlerOperation) => operation is Erc20BundlerOperation;
+export declare const isCallbackBundlerOperation: (operation: BundlerOperation) => operation is CallbackBundlerOperation;
+export declare const BLUE_INPUT_OPERATIONS: readonly ["Blue_SetAuthorization", "Blue_Borrow", "Blue_Repay", "Blue_Supply", "Blue_SupplyCollateral", "Blue_Withdraw", "Blue_WithdrawCollateral", "Blue_FlashLoan", "Blue_Paraswap_BuyDebt"];
 export type BlueInputBundlerOperationType = (typeof BLUE_INPUT_OPERATIONS)[number];
-export interface BlueInputBundlerOperationArgs extends Omit<OperationArgs, (typeof CALLBACK_OPERATIONS)[number]> {
-    Blue_SupplyCollateral: Omit<BlueOperationArgs["Blue_SupplyCollateral"], "callback"> & {
-        callback?: InputBundlerOperation[];
-    };
-    Blue_Supply: Omit<BlueOperationArgs["Blue_Supply"], "callback"> & {
-        callback?: InputBundlerOperation[];
-    };
-    Blue_Repay: Omit<BlueOperationArgs["Blue_Repay"], "callback"> & {
-        callback?: InputBundlerOperation[];
+export type BlueInputBundlerOperationArgs = Omit<OperationArgs, (typeof CALLBACK_OPERATIONS)[number]> & {
+    [OperationType in CallbackOperationType]: Omit<OperationArgs[OperationType], "callback"> & {
+        /**
+         * Inside a callback, the sender is forced to be the generalAdapter1.
+         */
+        callback?: UnionOmit<InputBundlerOperation, "sender">[];
     };
-}
+};
 export type BlueInputBundlerOperations = {
-    [OperationType in BlueInputBundlerOperationType]: WithOperationArgs<OperationType, BlueInputBundlerOperationArgs>;
+    [OperationType in BlueInputBundlerOperationType]: Omit<WithOperationArgs<OperationType, BlueInputBundlerOperationArgs>, "address">;
 };
 export type BlueInputBundlerOperation = BlueInputBundlerOperations[BlueInputBundlerOperationType];
 export declare const METAMORPHO_INPUT_OPERATIONS: readonly ["MetaMorpho_Deposit", "MetaMorpho_Withdraw"];
 export type MetaMorphoInputBundlerOperationType = (typeof METAMORPHO_INPUT_OPERATIONS)[number];
-export type MetaMorphoInputBundlerOperation = BundlerOperations[MetaMorphoInputBundlerOperationType];
-export declare const ERC20_INPUT_OPERATIONS: readonly ["Erc20_Wrap", "Erc20_Unwrap"];
+export type MetaMorphoInputBundlerOperation = MetaMorphoBundlerOperations[MetaMorphoInputBundlerOperationType];
+export declare const PARASWAP_INPUT_OPERATIONS: readonly ["Paraswap_Buy", "Paraswap_Sell"];
+export type ParaswapInputBundlerOperationType = (typeof PARASWAP_INPUT_OPERATIONS)[number];
+export type ParaswapInputBundlerOperation = BundlerOperations[ParaswapInputBundlerOperationType];
+export declare const ERC20_INPUT_OPERATIONS: readonly ["Erc20_Approve", "Erc20_Permit", "Erc20_Permit2", "Erc20_Transfer", "Erc20_Transfer2", "Erc20_Wrap", "Erc20_Unwrap"];
 export type Erc20InputBundlerOperationType = (typeof ERC20_INPUT_OPERATIONS)[number];
-export type Erc20InputBundlerOperation = BundlerOperations[Erc20InputBundlerOperationType];
-export interface InputBundlerOperationArgs extends BlueOperationArgs, MetaMorphoOperationArgs, Erc20OperationArgs {
+export type Erc20InputBundlerOperation = Erc20BundlerOperations[Erc20InputBundlerOperationType];
+export interface InputBundlerOperationArgs extends BlueOperationArgs, MetaMorphoOperationArgs, ParaswapOperationArgs, Erc20OperationArgs {
 }
-export type InputBundlerOperationType = BlueInputBundlerOperationType | MetaMorphoInputBundlerOperationType | Erc20InputBundlerOperationType;
-export type InputBundlerOperation = BlueInputBundlerOperation | MetaMorphoInputBundlerOperation | Erc20InputBundlerOperation;
+export type InputBundlerOperationType = BlueInputBundlerOperationType | MetaMorphoInputBundlerOperationType | ParaswapInputBundlerOperationType | Erc20InputBundlerOperationType;
+export type InputBundlerOperation = BlueInputBundlerOperation | MetaMorphoInputBundlerOperation | ParaswapInputBundlerOperation | Erc20InputBundlerOperation;
 export declare const isBlueInputBundlerOperation: (operation: {
     type: OperationType;
 }) => operation is BlueInputBundlerOperation;
@@ -57,3 +81,6 @@ export declare const isMetaMorphoInputBundlerOperation: (operation: {
 export declare const isErc20InputBundlerOperation: (operation: {
     type: OperationType;
 }) => operation is Erc20InputBundlerOperation;
+export declare const isParaswapInputBundlerOperation: (operation: {
+    type: OperationType;
+}) => operation is ParaswapInputBundlerOperation;

package/lib/types/operations.js

@@ -1,7 +1,8 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.isErc20InputBundlerOperation = exports.isMetaMorphoInputBundlerOperation = exports.isBlueInputBundlerOperation = exports.ERC20_INPUT_OPERATIONS = exports.METAMORPHO_INPUT_OPERATIONS = exports.BLUE_INPUT_OPERATIONS = exports.BUNDLER_OPERATIONS = void 0;
-exports.BUNDLER_OPERATIONS = [
+exports.isParaswapInputBundlerOperation = exports.isErc20InputBundlerOperation = exports.isMetaMorphoInputBundlerOperation = exports.isBlueInputBundlerOperation = exports.ERC20_INPUT_OPERATIONS = exports.PARASWAP_INPUT_OPERATIONS = exports.METAMORPHO_INPUT_OPERATIONS = exports.BLUE_INPUT_OPERATIONS = exports.isCallbackBundlerOperation = exports.isErc20BundlerOperation = exports.isMetaMorphoBundlerOperation = exports.isBlueBundlerOperation = exports.BUNDLER_OPERATIONS = exports.ERC20_BUNDLER_OPERATIONS = exports.PARASWAP_BUNDLER_OPERATIONS = exports.METAMORPHO_BUNDLER_OPERATIONS = exports.BLUE_BUNDLER_OPERATIONS = void 0;
+const simulation_sdk_1 = require("@morpho-org/simulation-sdk");
+exports.BLUE_BUNDLER_OPERATIONS = [
     "Blue_SetAuthorization",
     "Blue_Borrow",
     "Blue_Repay",
@@ -9,41 +10,44 @@ exports.BUNDLER_OPERATIONS = [
     "Blue_SupplyCollateral",
     "Blue_Withdraw",
     "Blue_WithdrawCollateral",
+    "Blue_FlashLoan",
+    "Blue_Paraswap_BuyDebt",
+];
+exports.METAMORPHO_BUNDLER_OPERATIONS = [
     "MetaMorpho_Deposit",
     "MetaMorpho_Withdraw",
     "MetaMorpho_PublicReallocate",
-    "Erc20_Approve",
-    "Erc20_Permit",
-    "Erc20_Permit2",
-    "Erc20_Transfer",
-    "Erc20_Transfer2",
-    "Erc20_Wrap",
-    "Erc20_Unwrap",
 ];
-exports.BLUE_INPUT_OPERATIONS = [
-    "Blue_Borrow",
-    "Blue_Repay",
-    "Blue_Supply",
-    "Blue_SupplyCollateral",
-    "Blue_Withdraw",
-    "Blue_WithdrawCollateral",
-    "Blue_SetAuthorization",
+exports.PARASWAP_BUNDLER_OPERATIONS = simulation_sdk_1.PARASWAP_OPERATIONS;
+exports.ERC20_BUNDLER_OPERATIONS = simulation_sdk_1.ERC20_OPERATIONS;
+exports.BUNDLER_OPERATIONS = [
+    ...exports.BLUE_BUNDLER_OPERATIONS,
+    ...exports.METAMORPHO_BUNDLER_OPERATIONS,
+    ...exports.ERC20_BUNDLER_OPERATIONS,
 ];
+const isBlueBundlerOperation = (operation) => {
+    return exports.BLUE_BUNDLER_OPERATIONS.includes(operation.type);
+};
+exports.isBlueBundlerOperation = isBlueBundlerOperation;
+const isMetaMorphoBundlerOperation = (operation) => {
+    return exports.METAMORPHO_BUNDLER_OPERATIONS.includes(operation.type);
+};
+exports.isMetaMorphoBundlerOperation = isMetaMorphoBundlerOperation;
+const isErc20BundlerOperation = (operation) => {
+    return exports.ERC20_BUNDLER_OPERATIONS.includes(operation.type);
+};
+exports.isErc20BundlerOperation = isErc20BundlerOperation;
+const isCallbackBundlerOperation = (operation) => {
+    return simulation_sdk_1.CALLBACK_OPERATIONS.includes(operation.type);
+};
+exports.isCallbackBundlerOperation = isCallbackBundlerOperation;
+exports.BLUE_INPUT_OPERATIONS = exports.BLUE_BUNDLER_OPERATIONS;
 exports.METAMORPHO_INPUT_OPERATIONS = [
     "MetaMorpho_Deposit",
     "MetaMorpho_Withdraw",
 ];
-exports.ERC20_INPUT_OPERATIONS = [
-    "Erc20_Wrap",
-    "Erc20_Unwrap",
-];
-// export const isBundlerOperation = (
-//   operation: Operation
-// ): operation is BundlerOperation => {
-//   return (BUNDLER_OPERATIONS as readonly OperationType[]).includes(
-//     operation.type
-//   );
-// };
+exports.PARASWAP_INPUT_OPERATIONS = exports.PARASWAP_BUNDLER_OPERATIONS;
+exports.ERC20_INPUT_OPERATIONS = exports.ERC20_BUNDLER_OPERATIONS;
 const isBlueInputBundlerOperation = (operation) => {
     return exports.BLUE_INPUT_OPERATIONS.includes(operation.type);
 };
@@ -56,3 +60,7 @@ const isErc20InputBundlerOperation = (operation) => {
     return exports.ERC20_INPUT_OPERATIONS.includes(operation.type);
 };
 exports.isErc20InputBundlerOperation = isErc20InputBundlerOperation;
+const isParaswapInputBundlerOperation = (operation) => {
+    return exports.PARASWAP_INPUT_OPERATIONS.includes(operation.type);
+};
+exports.isParaswapInputBundlerOperation = isParaswapInputBundlerOperation;

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": "3.1.3",
+  "version": "3.2.0-next.1",
   "author": "Morpho Association <contact@morpho.org>",
   "contributors": [
     "Rubilmax <rmilon@gmail.com>"
@@ -35,12 +35,12 @@
     "viem": "^2.23.0",
     "vitest": "^3.0.5",
     "@morpho-org/blue-sdk-viem": "^3.0.0",
-    "@morpho-org/blue-sdk": "^3.0.6",
-    "@morpho-org/morpho-ts": "^2.3.0",
     "@morpho-org/morpho-test": "^2.3.0",
+    "@morpho-org/morpho-ts": "^2.3.0",
     "@morpho-org/simulation-sdk": "^3.0.1",
-    "@morpho-org/test": "^2.1.3",
+    "@morpho-org/blue-sdk": "^3.0.6",
     "@morpho-org/simulation-sdk-wagmi": "^3.0.1",
+    "@morpho-org/test": "^2.1.3",
     "@morpho-org/test-wagmi": "^2.0.4"
   },
   "scripts": {