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

package/lib/BundlerAction.js

@@ -1,177 +1,207 @@
-import { aaveV2MigrationBundlerAbi, aaveV3MigrationBundlerAbi, aaveV3OptimizerMigrationBundlerAbi, compoundV2MigrationBundlerAbi, compoundV3MigrationBundlerAbi, erc20WrapperBundlerAbi, erc4626BundlerAbi, ethereumPermitBundlerAbi, morphoBundlerAbi, permit2BundlerAbi, permitBundlerAbi, stEthBundlerAbi, transferBundlerAbi, urdBundlerAbi, wNativeBundlerAbi, } from "./abis.js";
-import { encodeAbiParameters, encodeFunctionData, parseSignature, } from "viem";
+import { aaveV2MigrationAdapterAbi, aaveV3MigrationAdapterAbi, aaveV3OptimizerMigrationAdapterAbi, bundler3Abi, compoundV2MigrationAdapterAbi, compoundV3MigrationAdapterAbi, coreAdapterAbi, erc20WrapperAdapterAbi, ethereumGeneralAdapter1Abi, generalAdapter1Abi, universalRewardsDistributorAbi, } from "./abis.js";
+import { getChainAddresses, } from "@morpho-org/blue-sdk";
+import { blueAbi, erc2612Abi, permit2Abi, publicAllocatorAbi, } from "@morpho-org/blue-sdk-viem";
+import { encodeAbiParameters, encodeFunctionData, keccak256, maxUint256, parseSignature, toFunctionSelector, zeroHash, } from "viem";
 import { BundlerErrors } from "./errors.js";
+const reenterSelectorHash = keccak256(toFunctionSelector(bundler3Abi.find((item) => item.type === "function" && item.name === "reenter")));
 /**
  * Namespace to easily encode calls to the Bundler contract, using ethers.
  */
 export var BundlerAction;
 (function (BundlerAction) {
-    function encode({ type, args }) {
+    function encodeBundle(chainId, actions) {
+        const { bundler3: { bundler3, generalAdapter1 }, } = getChainAddresses(chainId);
+        let value = 0n;
+        let generalAdapter1Value = 0n;
+        for (const { type, args } of actions) {
+            if (type !== "nativeTransfer")
+                continue;
+            const [owner, recipient, amount] = args;
+            if (owner !== bundler3 &&
+                owner !== generalAdapter1 &&
+                (recipient === bundler3 || recipient === generalAdapter1))
+                value += amount;
+            if (owner !== generalAdapter1 && recipient === generalAdapter1)
+                generalAdapter1Value += amount;
+        }
+        const encodedActions = actions.flatMap(BundlerAction.encode.bind(null, chainId));
+        if (generalAdapter1Value > 0n)
+            encodedActions.unshift({
+                to: generalAdapter1,
+                value: generalAdapter1Value,
+                data: "0x",
+                skipRevert: false,
+                callbackHash: zeroHash,
+            });
+        return {
+            to: bundler3,
+            value,
+            data: encodeFunctionData({
+                abi: bundler3Abi,
+                functionName: "multicall",
+                args: [encodedActions],
+            }),
+        };
+    }
+    BundlerAction.encodeBundle = encodeBundle;
+    function encode(chainId, { type, args }) {
         switch (type) {
             /* ERC20 */
             case "nativeTransfer": {
-                return BundlerAction.nativeTransfer(...args);
+                return BundlerAction.nativeTransfer(chainId, ...args);
             }
             case "erc20Transfer": {
-                return BundlerAction.erc20Transfer(...args);
+                return BundlerAction.erc20Transfer(chainId, ...args);
             }
             case "erc20TransferFrom": {
-                return BundlerAction.erc20TransferFrom(...args);
+                return BundlerAction.erc20TransferFrom(chainId, ...args);
             }
             /* ERC20Wrapper */
             case "erc20WrapperDepositFor": {
-                return BundlerAction.erc20WrapperDepositFor(...args);
+                return BundlerAction.erc20WrapperDepositFor(chainId, ...args);
             }
             case "erc20WrapperWithdrawTo": {
-                return BundlerAction.erc20WrapperWithdrawTo(...args);
+                return BundlerAction.erc20WrapperWithdrawTo(chainId, ...args);
             }
             /* Permit */
             case "permit": {
-                const [asset, amount, deadline, signature, skipRevert = true] = args;
+                const [sender, asset, amount, deadline, signature, spender, skipRevert,] = args;
                 if (signature == null)
                     throw new BundlerErrors.MissingSignature();
-                return BundlerAction.permit(asset, amount, deadline, signature, skipRevert);
+                return BundlerAction.permit(chainId, sender, asset, amount, deadline, signature, spender, skipRevert);
             }
             case "permitDai": {
-                const [nonce, expiry, allowed, signature, skipRevert = true] = args;
+                const [sender, nonce, expiry, allowed, signature, spender, skipRevert] = args;
                 if (signature == null)
                     throw new BundlerErrors.MissingSignature();
-                return BundlerAction.permitDai(nonce, expiry, allowed, signature, skipRevert);
+                return BundlerAction.permitDai(chainId, sender, nonce, expiry, allowed, signature, spender, skipRevert);
             }
             /* Permit2 */
             case "approve2": {
-                const [permitSingle, signature, skipRevert = true] = args;
+                const [sender, permitSingle, signature, skipRevert] = args;
                 if (signature == null)
                     throw new BundlerErrors.MissingSignature();
-                return BundlerAction.approve2(permitSingle, signature, skipRevert);
+                return BundlerAction.approve2(chainId, sender, permitSingle, signature, skipRevert);
             }
             case "transferFrom2": {
-                return BundlerAction.transferFrom2(...args);
+                return BundlerAction.transferFrom2(chainId, ...args);
             }
             /* ERC4626 */
             case "erc4626Mint": {
-                return BundlerAction.erc4626Mint(...args);
+                return BundlerAction.erc4626Mint(chainId, ...args);
             }
             case "erc4626Deposit": {
-                return BundlerAction.erc4626Deposit(...args);
+                return BundlerAction.erc4626Deposit(chainId, ...args);
             }
             case "erc4626Withdraw": {
-                return BundlerAction.erc4626Withdraw(...args);
+                return BundlerAction.erc4626Withdraw(chainId, ...args);
             }
             case "erc4626Redeem": {
-                return BundlerAction.erc4626Redeem(...args);
+                return BundlerAction.erc4626Redeem(chainId, ...args);
             }
             /* Morpho */
             case "morphoSetAuthorizationWithSig": {
-                const [authorization, signature, skipRevert = true] = args;
+                const [authorization, signature, skipRevert] = args;
                 if (signature == null)
                     throw new BundlerErrors.MissingSignature();
-                return BundlerAction.morphoSetAuthorizationWithSig(authorization, signature, skipRevert);
+                return BundlerAction.morphoSetAuthorizationWithSig(chainId, authorization, signature, skipRevert);
             }
             case "morphoSupply": {
                 const [market, assets, shares, slippageAmount, onBehalf, onMorphoSupply,] = args;
-                return BundlerAction.morphoSupply(market, assets, shares, slippageAmount, onBehalf, onMorphoSupply.map(BundlerAction.encode));
+                return BundlerAction.morphoSupply(chainId, market, assets, shares, slippageAmount, onBehalf, onMorphoSupply.flatMap(BundlerAction.encode.bind(null, chainId)));
             }
             case "morphoSupplyCollateral": {
                 const [market, amount, onBehalf, onMorphoSupplyCollateral] = args;
-                return BundlerAction.morphoSupplyCollateral(market, amount, onBehalf, onMorphoSupplyCollateral.map(BundlerAction.encode));
+                return BundlerAction.morphoSupplyCollateral(chainId, market, amount, onBehalf, onMorphoSupplyCollateral.flatMap(BundlerAction.encode.bind(null, chainId)));
             }
             case "morphoBorrow": {
-                const [market, assets, shares, slippageAmount, receiver] = args;
-                return BundlerAction.morphoBorrow(market, assets, shares, slippageAmount, receiver);
+                return BundlerAction.morphoBorrow(chainId, ...args);
             }
             case "morphoRepay": {
                 const [market, assets, shares, slippageAmount, onBehalf, onMorphoRepay,] = args;
-                return BundlerAction.morphoRepay(market, assets, shares, slippageAmount, onBehalf, onMorphoRepay.map(BundlerAction.encode));
+                return BundlerAction.morphoRepay(chainId, market, assets, shares, slippageAmount, onBehalf, onMorphoRepay.flatMap(BundlerAction.encode.bind(null, chainId)));
             }
             case "morphoWithdraw": {
-                const [market, assets, shares, slippageAmount, receiver] = args;
-                return BundlerAction.morphoWithdraw(market, assets, shares, slippageAmount, receiver);
+                return BundlerAction.morphoWithdraw(chainId, ...args);
             }
             case "morphoWithdrawCollateral": {
-                const [market, amount, receiver] = args;
-                return BundlerAction.morphoWithdrawCollateral(market, amount, receiver);
+                return BundlerAction.morphoWithdrawCollateral(chainId, ...args);
             }
-            /* MetaMorpho */
+            /* PublicAllocator */
             case "reallocateTo": {
-                const [publicAllocator, vault, value, withdrawals, supplyMarket] = args;
-                return BundlerAction.metaMorphoReallocateTo(publicAllocator, vault, value, withdrawals, supplyMarket);
+                return BundlerAction.publicAllocatorReallocateTo(chainId, ...args);
             }
             /* Universal Rewards Distributor */
             case "urdClaim": {
-                const [distributor, account, reward, amount, proof, skipRevert = true] = args;
-                return BundlerAction.urdClaim(distributor, account, reward, amount, proof, skipRevert);
+                return BundlerAction.urdClaim(...args);
             }
             /* Wrapped Native */
             case "wrapNative": {
-                return BundlerAction.wrapNative(...args);
+                return BundlerAction.wrapNative(chainId, ...args);
             }
             case "unwrapNative": {
-                return BundlerAction.unwrapNative(...args);
+                return BundlerAction.unwrapNative(chainId, ...args);
             }
             /* stETH */
             case "stakeEth": {
-                return BundlerAction.stakeEth(...args);
+                return BundlerAction.stakeEth(chainId, ...args);
             }
             /* Wrapped stETH */
             case "wrapStEth": {
-                return BundlerAction.wrapStEth(...args);
+                return BundlerAction.wrapStEth(chainId, ...args);
             }
             case "unwrapStEth": {
-                return BundlerAction.unwrapStEth(...args);
+                return BundlerAction.unwrapStEth(chainId, ...args);
             }
             /* AaveV2 */
             case "aaveV2Repay": {
-                const [asset, amount, rateMode = 1n] = args;
-                return BundlerAction.aaveV2Repay(asset, amount, rateMode);
+                return BundlerAction.aaveV2Repay(chainId, ...args);
             }
             case "aaveV2Withdraw": {
-                return BundlerAction.aaveV2Withdraw(...args);
+                return BundlerAction.aaveV2Withdraw(chainId, ...args);
             }
             /* AaveV3 */
             case "aaveV3Repay": {
-                const [asset, amount, rateMode = 1n] = args;
-                return BundlerAction.aaveV3Repay(asset, amount, rateMode);
+                return BundlerAction.aaveV3Repay(chainId, ...args);
             }
             case "aaveV3Withdraw": {
-                return BundlerAction.aaveV3Withdraw(...args);
+                return BundlerAction.aaveV3Withdraw(chainId, ...args);
             }
             /* AaveV3 Optimizer */
             case "aaveV3OptimizerRepay": {
-                return BundlerAction.aaveV3OptimizerRepay(...args);
+                return BundlerAction.aaveV3OptimizerRepay(chainId, ...args);
             }
             case "aaveV3OptimizerWithdraw": {
-                const [underlying, amount, maxIterations = 4n] = args;
-                return BundlerAction.aaveV3OptimizerWithdraw(underlying, amount, maxIterations);
+                return BundlerAction.aaveV3OptimizerWithdraw(chainId, ...args);
             }
             case "aaveV3OptimizerWithdrawCollateral": {
-                return BundlerAction.aaveV3OptimizerWithdrawCollateral(...args);
+                return BundlerAction.aaveV3OptimizerWithdrawCollateral(chainId, ...args);
             }
             case "aaveV3OptimizerApproveManagerWithSig": {
-                const [isApproved, nonce, deadline, signature, skipRevert = true] = args;
+                const [owner, isApproved, nonce, deadline, signature, manager, skipRevert,] = args;
                 if (signature == null)
                     throw new BundlerErrors.MissingSignature();
-                return BundlerAction.aaveV3OptimizerApproveManagerWithSig(isApproved, nonce, deadline, signature, skipRevert);
+                return BundlerAction.aaveV3OptimizerApproveManagerWithSig(chainId, owner, isApproved, nonce, deadline, signature, manager, skipRevert);
             }
             /* CompoundV2 */
             case "compoundV2Repay": {
-                return BundlerAction.compoundV2Repay(...args);
+                return BundlerAction.compoundV2Repay(chainId, ...args);
             }
             case "compoundV2Redeem": {
-                return BundlerAction.compoundV2Redeem(...args);
+                return BundlerAction.compoundV2Redeem(chainId, ...args);
             }
             /* CompoundV3 */
             case "compoundV3Repay": {
-                return BundlerAction.compoundV3Repay(...args);
+                return BundlerAction.compoundV3Repay(chainId, ...args);
             }
             case "compoundV3WithdrawFrom": {
-                return BundlerAction.compoundV3WithdrawFrom(...args);
+                return BundlerAction.compoundV3WithdrawFrom(chainId, ...args);
             }
             case "compoundV3AllowBySig": {
-                const [instance, isAllowed, nonce, expiry, signature, skipRevert = true,] = args;
+                const [instance, owner, isAllowed, nonce, expiry, signature, manager, skipRevert,] = args;
                 if (signature == null)
                     throw new BundlerErrors.MissingSignature();
-                return BundlerAction.compoundV3AllowBySig(instance, isAllowed, nonce, expiry, signature, skipRevert);
+                return BundlerAction.compoundV3AllowBySig(chainId, instance, owner, isAllowed, nonce, expiry, signature, manager, skipRevert);
             }
         }
         throw Error(`unhandled action encoding: ${type}`);
@@ -179,215 +209,458 @@ export var BundlerAction;
     BundlerAction.encode = encode;
     /* ERC20 */
     /**
-     * Encodes a call to the Bundler to transfer native tokens (ETH on ethereum, MATIC on polygon, etc).
+     * Encodes a call to the Adapter to transfer native tokens (ETH on ethereum, MATIC on polygon, etc).
+     * @param chainId The chain id for which to encode the call.
+     * @param owner The owner of native tokens.
      * @param recipient The address to send native tokens to.
      * @param amount The amount of native tokens to send (in wei).
      */
-    function nativeTransfer(recipient, amount) {
-        return encodeFunctionData({
-            abi: transferBundlerAbi,
-            functionName: "nativeTransfer",
-            args: [recipient, amount],
-        });
+    function nativeTransfer(chainId, owner, recipient, amount) {
+        const { bundler3: { bundler3, generalAdapter1 }, } = getChainAddresses(chainId);
+        if (recipient === bundler3)
+            return [];
+        if (owner === generalAdapter1)
+            return [
+                {
+                    to: generalAdapter1,
+                    data: encodeFunctionData({
+                        abi: coreAdapterAbi,
+                        functionName: "nativeTransfer",
+                        args: [recipient, amount],
+                    }),
+                    value: 0n,
+                    skipRevert: false,
+                    callbackHash: zeroHash,
+                },
+            ];
+        return [
+            {
+                to: recipient,
+                data: "0x",
+                value: amount,
+                skipRevert: false,
+                callbackHash: zeroHash,
+            },
+        ];
     }
     BundlerAction.nativeTransfer = nativeTransfer;
     /**
-     * Encodes a call to the Bundler to transfer ERC20 tokens.
+     * Encodes a call to the Adapter to transfer ERC20 tokens.
+     * @param chainId The chain id for which to encode the call.
      * @param asset The address of the ERC20 token to transfer.
      * @param recipient The address to send tokens to.
      * @param amount The amount of tokens to send.
      */
-    function erc20Transfer(asset, recipient, amount) {
-        return encodeFunctionData({
-            abi: transferBundlerAbi,
-            functionName: "erc20Transfer",
-            args: [asset, recipient, amount],
-        });
+    function erc20Transfer(chainId, asset, recipient, amount) {
+        const { bundler3: { generalAdapter1 }, } = getChainAddresses(chainId);
+        return [
+            {
+                to: generalAdapter1,
+                data: encodeFunctionData({
+                    abi: coreAdapterAbi,
+                    functionName: "erc20Transfer",
+                    args: [asset, recipient, amount],
+                }),
+                value: 0n,
+                skipRevert: false,
+                callbackHash: zeroHash,
+            },
+        ];
     }
     BundlerAction.erc20Transfer = erc20Transfer;
     /**
-     * Encodes a call to the Bundler to transfer ERC20 tokens from the sender to the Bundler.
+     * Encodes a call to the Adapter to transfer ERC20 tokens from the sender to the Bundler.
+     * @param chainId The chain id for which to encode the call.
      * @param asset The address of the ERC20 token to transfer.
      * @param amount The amount of tokens to send.
+     * @param recipient The recipient of ERC20 tokens. Defaults to the chain's bundler3 general adapter.
      */
-    function erc20TransferFrom(asset, amount) {
-        return encodeFunctionData({
-            abi: transferBundlerAbi,
-            functionName: "erc20TransferFrom",
-            args: [asset, amount],
-        });
+    function erc20TransferFrom(chainId, asset, amount, recipient) {
+        const { bundler3: { generalAdapter1 }, } = getChainAddresses(chainId);
+        recipient ??= generalAdapter1;
+        return [
+            {
+                to: generalAdapter1,
+                data: encodeFunctionData({
+                    abi: generalAdapter1Abi,
+                    functionName: "erc20TransferFrom",
+                    args: [asset, recipient, amount],
+                }),
+                value: 0n,
+                skipRevert: false,
+                callbackHash: zeroHash,
+            },
+        ];
     }
     BundlerAction.erc20TransferFrom = erc20TransferFrom;
     /* Permit */
     /**
-     * Encodes a call to the Bundler to permit an ERC20 token.
+     * Encodes a call to the Adapter to permit an ERC20 token.
+     * @param chainId The chain id for which to encode the call.
+     * @param owner The address which owns the tokens.
      * @param asset The address of the ERC20 token to permit.
      * @param amount The amount of tokens to permit.
      * @param deadline The timestamp until which the signature is valid.
      * @param signature The Ethers signature to permit the tokens.
+     * @param spender The address allowed to spend the tokens.
      * @param skipRevert Whether to allow the permit to revert without making the whole multicall revert.
      */
-    function permit(asset, amount, deadline, signature, skipRevert) {
+    function permit(chainId, owner, asset, amount, deadline, signature, spender, skipRevert = true) {
+        const { bundler3: { generalAdapter1 }, } = getChainAddresses(chainId);
         const { r, s, yParity } = parseSignature(signature);
-        return encodeFunctionData({
-            abi: permitBundlerAbi,
-            functionName: "permit",
-            args: [asset, amount, deadline, yParity + 27, r, s, skipRevert],
-        });
+        spender ??= generalAdapter1;
+        return [
+            {
+                to: asset,
+                data: encodeFunctionData({
+                    abi: erc2612Abi,
+                    functionName: "permit",
+                    args: [owner, spender, amount, deadline, yParity + 27, r, s],
+                }),
+                value: 0n,
+                skipRevert,
+                callbackHash: zeroHash,
+            },
+        ];
     }
     BundlerAction.permit = permit;
     /**
-     * Encodes a call to the Bundler to permit DAI.
+     * Encodes a call to the Adapter to permit DAI.
+     * @param chainId The chain id for which to encode the call.
+     * @param owner The address which owns the tokens.
      * @param nonce The permit nonce used.
      * @param expiry The timestamp until which the signature is valid.
      * @param allowed The amount of DAI to permit.
      * @param signature The Ethers signature to permit the tokens.
+     * @param spender The address allowed to spend the tokens.
      * @param skipRevert Whether to allow the permit to revert without making the whole multicall revert.
      */
-    function permitDai(nonce, expiry, allowed, signature, skipRevert) {
+    function permitDai(chainId, owner, nonce, expiry, allowed, signature, spender, skipRevert = true) {
+        const { dai, bundler3: { generalAdapter1 }, } = getChainAddresses(chainId);
+        if (dai == null)
+            throw new BundlerErrors.UnexpectedAction("permitDai", chainId);
+        spender ??= generalAdapter1;
         const { r, s, yParity } = parseSignature(signature);
-        return encodeFunctionData({
-            abi: ethereumPermitBundlerAbi,
-            functionName: "permitDai",
-            args: [nonce, expiry, allowed, yParity + 27, r, s, skipRevert],
-        });
+        return [
+            {
+                to: dai,
+                data: encodeFunctionData({
+                    abi: [
+                        {
+                            constant: false,
+                            inputs: [
+                                { name: "holder", type: "address" },
+                                { name: "spender", type: "address" },
+                                { name: "nonce", type: "uint256" },
+                                { name: "expiry", type: "uint256" },
+                                { name: "allowed", type: "bool" },
+                                { name: "v", type: "uint8" },
+                                { name: "r", type: "bytes32" },
+                                { name: "s", type: "bytes32" },
+                            ],
+                            name: "permit",
+                            outputs: [],
+                            payable: false,
+                            stateMutability: "nonpayable",
+                            type: "function",
+                        },
+                    ],
+                    functionName: "permit",
+                    args: [owner, spender, nonce, expiry, allowed, yParity + 27, r, s],
+                }),
+                value: 0n,
+                skipRevert,
+                callbackHash: zeroHash,
+            },
+        ];
     }
     BundlerAction.permitDai = permitDai;
     /* Permit2 */
     /**
-     * Encodes a call to the Bundler to permit ERC20 tokens via Permit2.
+     * Encodes a call to the Adapter to permit ERC20 tokens via Permit2.
+     * @param chainId The chain id for which to encode the call.
+     * @param owner The owner of ERC20 tokens.
      * @param permitSingle The permit details to submit to Permit2.
      * @param signature The Ethers signature to permit the tokens.
      * @param skipRevert Whether to allow the permit to revert without making the whole multicall revert.
      */
-    function approve2(permitSingle, signature, skipRevert) {
-        return encodeFunctionData({
-            abi: permit2BundlerAbi,
-            functionName: "approve2",
-            args: [permitSingle, signature, skipRevert],
-        });
+    function approve2(chainId, owner, permitSingle, signature, skipRevert = true) {
+        const { permit2 } = getChainAddresses(chainId);
+        if (permit2 == null)
+            throw new BundlerErrors.UnexpectedAction("approve2", chainId);
+        return [
+            {
+                to: permit2,
+                data: encodeFunctionData({
+                    abi: permit2Abi,
+                    functionName: "permit",
+                    args: [owner, permitSingle, signature],
+                }),
+                value: 0n,
+                skipRevert,
+                callbackHash: zeroHash,
+            },
+        ];
     }
     BundlerAction.approve2 = approve2;
     /**
-     * Encodes a call to the Bundler to transfer ERC20 tokens via Permit2 from the sender to the Bundler.
+     * Encodes a call to the Adapter to transfer ERC20 tokens via Permit2 from the sender to the Bundler.
+     * @param chainId The chain id for which to encode the call.
      * @param asset The address of the ERC20 token to transfer.
+     * @param owner The owner of ERC20 tokens.
      * @param amount The amount of tokens to send.
+     * @param recipient The recipient of ERC20 tokens. Defaults to the chain's bundler3 general adapter.
      */
-    function transferFrom2(asset, amount) {
-        return encodeFunctionData({
-            abi: permit2BundlerAbi,
-            functionName: "transferFrom2",
-            args: [asset, amount],
-        });
+    function transferFrom2(chainId, asset, owner, amount, recipient) {
+        const { permit2, bundler3: { generalAdapter1 }, } = getChainAddresses(chainId);
+        if (permit2 == null)
+            throw new BundlerErrors.UnexpectedAction("transferFrom2", chainId);
+        recipient ??= generalAdapter1;
+        return [
+            {
+                to: permit2,
+                data: encodeFunctionData({
+                    abi: permit2Abi,
+                    functionName: "transferFrom",
+                    // TODO: batch all permit2 transfers via transferFrom(AllowanceTransferDetails[] calldata)
+                    args: [owner, recipient, amount, asset],
+                }),
+                value: 0n,
+                skipRevert: false,
+                callbackHash: zeroHash,
+            },
+        ];
     }
     BundlerAction.transferFrom2 = transferFrom2;
     /* ERC20 Wrapper */
     /**
-     * Encodes a call to the Bundler to wrap ERC20 tokens via the provided ERC20Wrapper.
+     * Encodes a call to the Adapter to wrap ERC20 tokens via the provided ERC20Wrapper.
+     * @param chainId The chain id for which to encode the call.
      * @param wrapper The address of the ERC20 wrapper token.
+     * @param underlying The address of the underlying ERC20 token.
      * @param amount The amount of tokens to send.
      */
-    function erc20WrapperDepositFor(wrapper, amount) {
-        return encodeFunctionData({
-            abi: erc20WrapperBundlerAbi,
-            functionName: "erc20WrapperDepositFor",
-            args: [wrapper, amount],
-        });
+    function erc20WrapperDepositFor(chainId, wrapper, underlying, amount) {
+        const { bundler3: { generalAdapter1, erc20WrapperAdapter }, } = getChainAddresses(chainId);
+        if (erc20WrapperAdapter == null)
+            throw new BundlerErrors.UnexpectedAction("erc20WrapperDepositFor", chainId);
+        return [
+            {
+                to: generalAdapter1,
+                data: encodeFunctionData({
+                    abi: generalAdapter1Abi,
+                    functionName: "erc20Transfer",
+                    args: [underlying, erc20WrapperAdapter, maxUint256],
+                }),
+                value: 0n,
+                skipRevert: false,
+                callbackHash: zeroHash,
+            },
+            {
+                to: erc20WrapperAdapter,
+                data: encodeFunctionData({
+                    abi: erc20WrapperAdapterAbi,
+                    functionName: "erc20WrapperDepositFor",
+                    args: [wrapper, amount],
+                }),
+                value: 0n,
+                skipRevert: false,
+                callbackHash: zeroHash,
+            },
+            {
+                to: erc20WrapperAdapter,
+                data: encodeFunctionData({
+                    abi: erc20WrapperAdapterAbi,
+                    functionName: "erc20Transfer",
+                    args: [underlying, generalAdapter1, maxUint256],
+                }),
+                value: 0n,
+                skipRevert: false,
+                callbackHash: zeroHash,
+            },
+        ];
     }
     BundlerAction.erc20WrapperDepositFor = erc20WrapperDepositFor;
     /**
-     * Encodes a call to the Bundler to unwrap ERC20 tokens from the provided ERC20Wrapper.
+     * Encodes a call to the Adapter to unwrap ERC20 tokens from the provided ERC20Wrapper.
+     * @param chainId The chain id for which to encode the call.
      * @param wrapper The address of the ERC20 wrapper token.
      * @param account The address to send the underlying ERC20 tokens.
      * @param amount The amount of tokens to send.
      */
-    function erc20WrapperWithdrawTo(wrapper, account, amount) {
-        return encodeFunctionData({
-            abi: erc20WrapperBundlerAbi,
-            functionName: "erc20WrapperWithdrawTo",
-            args: [wrapper, account, amount],
-        });
+    function erc20WrapperWithdrawTo(chainId, wrapper, receiver, amount) {
+        const { bundler3: { generalAdapter1, erc20WrapperAdapter }, } = getChainAddresses(chainId);
+        if (erc20WrapperAdapter == null)
+            throw new BundlerErrors.UnexpectedAction("erc20WrapperWithdrawTo", chainId);
+        return [
+            {
+                to: generalAdapter1,
+                data: encodeFunctionData({
+                    abi: generalAdapter1Abi,
+                    functionName: "erc20Transfer",
+                    args: [wrapper, erc20WrapperAdapter, maxUint256],
+                }),
+                value: 0n,
+                skipRevert: false,
+                callbackHash: zeroHash,
+            },
+            {
+                to: erc20WrapperAdapter,
+                data: encodeFunctionData({
+                    abi: erc20WrapperAdapterAbi,
+                    functionName: "erc20WrapperWithdrawTo",
+                    args: [wrapper, receiver, amount],
+                }),
+                value: 0n,
+                skipRevert: false,
+                callbackHash: zeroHash,
+            },
+            {
+                to: erc20WrapperAdapter,
+                data: encodeFunctionData({
+                    abi: erc20WrapperAdapterAbi,
+                    functionName: "erc20Transfer",
+                    args: [wrapper, generalAdapter1, maxUint256],
+                }),
+                value: 0n,
+                skipRevert: false,
+                callbackHash: zeroHash,
+            },
+        ];
     }
     BundlerAction.erc20WrapperWithdrawTo = erc20WrapperWithdrawTo;
     /* ERC4626 */
     /**
-     * Encodes a call to the Bundler to mint shares of the provided ERC4626 vault.
+     * Encodes a call to the Adapter to mint shares of the provided ERC4626 vault.
+     * @param chainId The chain id for which to encode the call.
      * @param erc4626 The address of the ERC4626 vault.
      * @param shares The amount of shares to mint.
-     * @param maxAssets The maximum amount of assets to deposit (protects the sender from unexpected slippage).
+     * @param maxSharePrice The maximum amount of assets to pay to get 1 share (scaled by RAY).
      * @param receiver The address to send the shares to.
      */
-    function erc4626Mint(erc4626, shares, maxAssets, receiver) {
-        return encodeFunctionData({
-            abi: erc4626BundlerAbi,
-            functionName: "erc4626Mint",
-            args: [erc4626, shares, maxAssets, receiver],
-        });
+    function erc4626Mint(chainId, erc4626, shares, maxSharePrice, receiver) {
+        const { bundler3: { generalAdapter1 }, } = getChainAddresses(chainId);
+        return [
+            {
+                to: generalAdapter1,
+                data: encodeFunctionData({
+                    abi: generalAdapter1Abi,
+                    functionName: "erc4626Mint",
+                    args: [erc4626, shares, maxSharePrice, receiver],
+                }),
+                value: 0n,
+                skipRevert: false,
+                callbackHash: zeroHash,
+            },
+        ];
     }
     BundlerAction.erc4626Mint = erc4626Mint;
     /**
-     * Encodes a call to the Bundler to deposit assets into the provided ERC4626 vault.
+     * Encodes a call to the Adapter to deposit assets into the provided ERC4626 vault.
+     * @param chainId The chain id for which to encode the call.
      * @param erc4626 The address of the ERC4626 vault.
      * @param assets The amount of assets to deposit.
-     * @param minShares The minimum amount of shares to mint (protects the sender from unexpected slippage).
+     * @param maxSharePrice The maximum amount of assets to pay to get 1 share (scaled by RAY).
      * @param receiver The address to send the shares to.
      */
-    function erc4626Deposit(erc4626, assets, minShares, receiver) {
-        return encodeFunctionData({
-            abi: erc4626BundlerAbi,
-            functionName: "erc4626Deposit",
-            args: [erc4626, assets, minShares, receiver],
-        });
+    function erc4626Deposit(chainId, erc4626, assets, maxSharePrice, receiver) {
+        const { bundler3: { generalAdapter1 }, } = getChainAddresses(chainId);
+        return [
+            {
+                to: generalAdapter1,
+                data: encodeFunctionData({
+                    abi: generalAdapter1Abi,
+                    functionName: "erc4626Deposit",
+                    args: [erc4626, assets, maxSharePrice, receiver],
+                }),
+                value: 0n,
+                skipRevert: false,
+                callbackHash: zeroHash,
+            },
+        ];
     }
     BundlerAction.erc4626Deposit = erc4626Deposit;
     /**
-     * Encodes a call to the Bundler to withdraw assets from the provided ERC4626 vault.
+     * Encodes a call to the Adapter to withdraw assets from the provided ERC4626 vault.
+     * @param chainId The chain id for which to encode the call.
      * @param erc4626 The address of the ERC4626 vault.
      * @param assets The amount of assets to withdraw.
-     * @param maxShares The maximum amount of shares to redeem (protects the sender from unexpected slippage).
+     * @param minSharePrice The minimum number of assets to receive per share (scaled by RAY).
      * @param receiver The address to send the assets to.
+     * @param owner The address on behalf of which the assets are withdrawn.
      */
-    function erc4626Withdraw(erc4626, assets, maxShares, receiver, owner) {
-        return encodeFunctionData({
-            abi: erc4626BundlerAbi,
-            functionName: "erc4626Withdraw",
-            args: [erc4626, assets, maxShares, receiver, owner],
-        });
+    function erc4626Withdraw(chainId, erc4626, assets, minSharePrice, receiver, owner) {
+        const { bundler3: { generalAdapter1 }, } = getChainAddresses(chainId);
+        return [
+            {
+                to: generalAdapter1,
+                data: encodeFunctionData({
+                    abi: generalAdapter1Abi,
+                    functionName: "erc4626Withdraw",
+                    args: [erc4626, assets, minSharePrice, receiver, owner],
+                }),
+                value: 0n,
+                skipRevert: false,
+                callbackHash: zeroHash,
+            },
+        ];
     }
     BundlerAction.erc4626Withdraw = erc4626Withdraw;
     /**
-     * Encodes a call to the Bundler to redeem shares from the provided ERC4626 vault.
+     * Encodes a call to the Adapter to redeem shares from the provided ERC4626 vault.
+     * @param chainId The chain id for which to encode the call.
      * @param erc4626 The address of the ERC4626 vault.
      * @param shares The amount of shares to redeem.
-     * @param minAssets The minimum amount of assets to withdraw (protects the sender from unexpected slippage).
+     * @param minSharePrice The minimum number of assets to receive per share (scaled by RAY).
      * @param receiver The address to send the assets to.
+     * @param owner The address on behalf of which the assets are withdrawn.
      */
-    function erc4626Redeem(erc4626, shares, minAssets, receiver, owner) {
-        return encodeFunctionData({
-            abi: erc4626BundlerAbi,
-            functionName: "erc4626Redeem",
-            args: [erc4626, shares, minAssets, receiver, owner],
-        });
+    function erc4626Redeem(chainId, erc4626, shares, minSharePrice, receiver, owner) {
+        const { bundler3: { generalAdapter1 }, } = getChainAddresses(chainId);
+        return [
+            {
+                to: generalAdapter1,
+                data: encodeFunctionData({
+                    abi: generalAdapter1Abi,
+                    functionName: "erc4626Redeem",
+                    args: [erc4626, shares, minSharePrice, receiver, owner],
+                }),
+                value: 0n,
+                skipRevert: false,
+                callbackHash: zeroHash,
+            },
+        ];
     }
     BundlerAction.erc4626Redeem = erc4626Redeem;
     /* Morpho */
     /**
-     * Encodes a call to the Bundler to authorize an account on Morpho Blue.
+     * Encodes a call to the Adapter to authorize an account on Morpho Blue.
+     * @param chainId The chain id for which to encode the call.
      * @param authorization The authorization details to submit to Morpho Blue.
      * @param signature The Ethers signature to authorize the account.
      * @param skipRevert Whether to allow the authorization call to revert without making the whole multicall revert.
      */
-    function morphoSetAuthorizationWithSig(authorization, signature, skipRevert) {
+    function morphoSetAuthorizationWithSig(chainId, authorization, signature, skipRevert = true) {
+        const { morpho } = getChainAddresses(chainId);
         const { r, s, yParity } = parseSignature(signature);
-        return encodeFunctionData({
-            abi: morphoBundlerAbi,
-            functionName: "morphoSetAuthorizationWithSig",
-            args: [authorization, { v: yParity + 27, r, s }, skipRevert],
-        });
+        return [
+            {
+                to: morpho,
+                data: encodeFunctionData({
+                    abi: blueAbi,
+                    functionName: "setAuthorizationWithSig",
+                    args: [authorization, { v: yParity + 27, r, s }],
+                }),
+                value: 0n,
+                skipRevert,
+                callbackHash: zeroHash,
+            },
+        ];
     }
     BundlerAction.morphoSetAuthorizationWithSig = morphoSetAuthorizationWithSig;
     /**
-     * Encodes a call to the Bundler to supply to a Morpho Blue market.
+     * Encodes a call to the Adapter to supply to a Morpho Blue market.
+     * @param chainId The chain id for which to encode the call.
      * @param market The market params to supply to.
      * @param assets The amount of assets to supply.
      * @param shares The amount of supply shares to mint.
@@ -395,59 +668,85 @@ export var BundlerAction;
      * @param onBehalf The address to supply on behalf of.
      * @param callbackCalls The array of calls to execute inside Morpho Blue's `onMorphoSupply` callback.
      */
-    function morphoSupply(market, assets, shares, slippageAmount, onBehalf, callbackCalls) {
-        return encodeFunctionData({
-            abi: morphoBundlerAbi,
-            functionName: "morphoSupply",
-            args: [
-                market,
-                assets,
-                shares,
-                slippageAmount,
-                onBehalf,
-                encodeAbiParameters([{ type: "bytes[]" }], [callbackCalls]),
-            ],
-        });
+    function morphoSupply(chainId, market, assets, shares, slippageAmount, onBehalf, callbackCalls) {
+        const { bundler3: { generalAdapter1 }, } = getChainAddresses(chainId);
+        const reenter = callbackCalls.length > 0;
+        const reenterData = reenter
+            ? encodeAbiParameters(bundler3Abi.find((item) => item.name === "reenter").inputs, [callbackCalls])
+            : "0x";
+        return [
+            {
+                to: generalAdapter1,
+                data: encodeFunctionData({
+                    abi: generalAdapter1Abi,
+                    functionName: "morphoSupply",
+                    args: [market, assets, shares, slippageAmount, onBehalf, reenterData],
+                }),
+                value: 0n,
+                skipRevert: false,
+                callbackHash: reenter ? keccak256(reenterData) : zeroHash,
+            },
+        ];
     }
     BundlerAction.morphoSupply = morphoSupply;
     /**
-     * Encodes a call to the Bundler to supply collateral to a Morpho Blue market.
+     * Encodes a call to the Adapter to supply collateral to a Morpho Blue market.
+     * @param chainId The chain id for which to encode the call.
      * @param market The market params to supply to.
      * @param assets The amount of assets to supply.
      * @param onBehalf The address to supply on behalf of.
      * @param callbackCalls The array of calls to execute inside Morpho Blue's `onMorphoSupplyCollateral` callback.
      */
-    function morphoSupplyCollateral(market, assets, onBehalf, callbackCalls) {
-        return encodeFunctionData({
-            abi: morphoBundlerAbi,
-            functionName: "morphoSupplyCollateral",
-            args: [
-                market,
-                assets,
-                onBehalf,
-                encodeAbiParameters([{ type: "bytes[]" }], [callbackCalls]),
-            ],
-        });
+    function morphoSupplyCollateral(chainId, market, assets, onBehalf, callbackCalls) {
+        const { bundler3: { generalAdapter1 }, } = getChainAddresses(chainId);
+        const reenter = callbackCalls.length > 0;
+        const reenterData = reenter
+            ? encodeAbiParameters(bundler3Abi.find((item) => item.name === "reenter").inputs, [callbackCalls])
+            : "0x";
+        return [
+            {
+                to: generalAdapter1,
+                data: encodeFunctionData({
+                    abi: generalAdapter1Abi,
+                    functionName: "morphoSupplyCollateral",
+                    args: [market, assets, onBehalf, reenterData],
+                }),
+                value: 0n,
+                skipRevert: false,
+                callbackHash: reenter ? keccak256(reenterData) : zeroHash,
+            },
+        ];
     }
     BundlerAction.morphoSupplyCollateral = morphoSupplyCollateral;
     /**
-     * Encodes a call to the Bundler to borrow from a Morpho Blue market.
+     * Encodes a call to the Adapter to borrow from a Morpho Blue market.
+     * @param chainId The chain id for which to encode the call.
      * @param market The market params to borrow from.
      * @param assets The amount of assets to borrow.
      * @param shares The amount of borrow shares to mint.
      * @param slippageAmount The minimum (resp. maximum) amount of assets (resp. borrow shares) to borrow (resp. mint) (protects the sender from unexpected slippage).
      * @param receiver The address to send borrowed tokens to.
      */
-    function morphoBorrow(market, assets, shares, slippageAmount, receiver) {
-        return encodeFunctionData({
-            abi: morphoBundlerAbi,
-            functionName: "morphoBorrow",
-            args: [market, assets, shares, slippageAmount, receiver],
-        });
+    function morphoBorrow(chainId, market, assets, shares, slippageAmount, receiver) {
+        const { bundler3: { generalAdapter1 }, } = getChainAddresses(chainId);
+        return [
+            {
+                to: generalAdapter1,
+                data: encodeFunctionData({
+                    abi: generalAdapter1Abi,
+                    functionName: "morphoBorrow",
+                    args: [market, assets, shares, slippageAmount, receiver],
+                }),
+                value: 0n,
+                skipRevert: false,
+                callbackHash: zeroHash,
+            },
+        ];
     }
     BundlerAction.morphoBorrow = morphoBorrow;
     /**
-     * Encodes a call to the Bundler to repay to a Morpho Blue market.
+     * Encodes a call to the Adapter to repay to a Morpho Blue market.
+     * @param chainId The chain id for which to encode the call.
      * @param market The market params to repay to.
      * @param assets The amount of assets to repay.
      * @param shares The amount of borrow shares to redeem.
@@ -455,88 +754,138 @@ export var BundlerAction;
      * @param onBehalf The address to repay on behalf of.
      * @param callbackCalls The array of calls to execute inside Morpho Blue's `onMorphoSupply` callback.
      */
-    function morphoRepay(market, assets, shares, slippageAmount, onBehalf, callbackCalls) {
-        return encodeFunctionData({
-            abi: morphoBundlerAbi,
-            functionName: "morphoRepay",
-            args: [
-                market,
-                assets,
-                shares,
-                slippageAmount,
-                onBehalf,
-                encodeAbiParameters([{ type: "bytes[]" }], [callbackCalls]),
-            ],
-        });
+    function morphoRepay(chainId, market, assets, shares, slippageAmount, onBehalf, callbackCalls) {
+        const { bundler3: { generalAdapter1 }, } = getChainAddresses(chainId);
+        const reenter = callbackCalls.length > 0;
+        const reenterData = reenter
+            ? encodeAbiParameters(bundler3Abi.find((item) => item.name === "reenter").inputs, [callbackCalls])
+            : "0x";
+        return [
+            {
+                to: generalAdapter1,
+                data: encodeFunctionData({
+                    abi: generalAdapter1Abi,
+                    functionName: "morphoRepay",
+                    args: [market, assets, shares, slippageAmount, onBehalf, reenterData],
+                }),
+                value: 0n,
+                skipRevert: false,
+                callbackHash: reenter ? keccak256(reenterData) : zeroHash,
+            },
+        ];
     }
     BundlerAction.morphoRepay = morphoRepay;
     /**
-     * Encodes a call to the Bundler to withdraw from a Morpho Blue market.
+     * Encodes a call to the Adapter to withdraw from a Morpho Blue market.
+     * @param chainId The chain id for which to encode the call.
      * @param market The market params to withdraw from.
      * @param assets The amount of assets to withdraw.
      * @param shares The amount of supply shares to redeem.
      * @param slippageAmount The minimum (resp. maximum) amount of assets (resp. supply shares) to withdraw (resp. redeem) (protects the sender from unexpected slippage).
      * @param receiver The address to send withdrawn tokens to.
      */
-    function morphoWithdraw(market, assets, shares, slippageAmount, receiver) {
-        return encodeFunctionData({
-            abi: morphoBundlerAbi,
-            functionName: "morphoWithdraw",
-            args: [market, assets, shares, slippageAmount, receiver],
-        });
+    function morphoWithdraw(chainId, market, assets, shares, slippageAmount, receiver) {
+        const { bundler3: { generalAdapter1 }, } = getChainAddresses(chainId);
+        return [
+            {
+                to: generalAdapter1,
+                data: encodeFunctionData({
+                    abi: generalAdapter1Abi,
+                    functionName: "morphoWithdraw",
+                    args: [market, assets, shares, slippageAmount, receiver],
+                }),
+                value: 0n,
+                skipRevert: false,
+                callbackHash: zeroHash,
+            },
+        ];
     }
     BundlerAction.morphoWithdraw = morphoWithdraw;
     /**
-     * Encodes a call to the Bundler to withdraw collateral from a Morpho Blue market.
+     * Encodes a call to the Adapter to withdraw collateral from a Morpho Blue market.
+     * @param chainId The chain id for which to encode the call.
      * @param market The market params to withdraw from.
      * @param assets The amount of assets to withdraw.
      * @param receiver The address to send withdrawn tokens to.
      */
-    function morphoWithdrawCollateral(market, assets, receiver) {
-        return encodeFunctionData({
-            abi: morphoBundlerAbi,
-            functionName: "morphoWithdrawCollateral",
-            args: [market, assets, receiver],
-        });
+    function morphoWithdrawCollateral(chainId, market, assets, receiver) {
+        const { bundler3: { generalAdapter1 }, } = getChainAddresses(chainId);
+        return [
+            {
+                to: generalAdapter1,
+                data: encodeFunctionData({
+                    abi: generalAdapter1Abi,
+                    functionName: "morphoWithdrawCollateral",
+                    args: [market, assets, receiver],
+                }),
+                value: 0n,
+                skipRevert: false,
+                callbackHash: zeroHash,
+            },
+        ];
     }
     BundlerAction.morphoWithdrawCollateral = morphoWithdrawCollateral;
     /**
-     * Encodes a call to the Bundler to flash loan from Morpho Blue.
+     * Encodes a call to the Adapter 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 callbackCalls The array of calls to execute inside Morpho Blue's `onMorphoFlashLoan` callback.
      */
-    function morphoFlashLoan(asset, amount, callbackCalls) {
-        return encodeFunctionData({
-            abi: morphoBundlerAbi,
-            functionName: "morphoFlashLoan",
-            args: [
-                asset,
-                amount,
-                encodeAbiParameters([{ type: "bytes[]" }], [callbackCalls]),
-            ],
-        });
+    function morphoFlashLoan(chainId, asset, amount, callbackCalls) {
+        const { bundler3: { generalAdapter1 }, } = getChainAddresses(chainId);
+        return [
+            {
+                to: generalAdapter1,
+                data: encodeFunctionData({
+                    abi: generalAdapter1Abi,
+                    functionName: "morphoFlashLoan",
+                    args: [
+                        asset,
+                        amount,
+                        encodeFunctionData({
+                            abi: bundler3Abi,
+                            functionName: "reenter",
+                            args: [callbackCalls],
+                        }),
+                    ],
+                }),
+                value: 0n,
+                skipRevert: false,
+                callbackHash: keccak256(`${generalAdapter1}${reenterSelectorHash}`),
+            },
+        ];
     }
     BundlerAction.morphoFlashLoan = morphoFlashLoan;
     /**
-     * Encodes a call to the Bundler to trigger a public reallocation on the PublicAllocator.
-     * @param publicAllocator The address of the PublicAllocator to use.
+     * Encodes a call to the Adapter to trigger a public reallocation on the PublicAllocator.
+     * @param chainId The chain id for which to encode the call.
      * @param vault The vault to reallocate.
-     * @param value The value of the call. Can be used to pay the vault reallocation fees.
+     * @param fee The vault public reallocation fee.
      * @param withdrawals The array of withdrawals to perform, before supplying everything to the supply market.
      * @param supplyMarketParams The market params to reallocate to.
      */
-    function metaMorphoReallocateTo(publicAllocator, vault, value, withdrawals, supplyMarketParams) {
-        return encodeFunctionData({
-            abi: morphoBundlerAbi,
-            functionName: "reallocateTo",
-            args: [publicAllocator, vault, value, withdrawals, supplyMarketParams],
-        });
+    function publicAllocatorReallocateTo(chainId, vault, fee, withdrawals, supplyMarketParams) {
+        const { publicAllocator } = getChainAddresses(chainId);
+        return [
+            {
+                to: publicAllocator,
+                data: encodeFunctionData({
+                    abi: publicAllocatorAbi,
+                    functionName: "reallocateTo",
+                    args: [vault, withdrawals, supplyMarketParams],
+                }),
+                value: fee,
+                skipRevert: false,
+                callbackHash: zeroHash,
+            },
+        ];
     }
-    BundlerAction.metaMorphoReallocateTo = metaMorphoReallocateTo;
+    BundlerAction.publicAllocatorReallocateTo = publicAllocatorReallocateTo;
     /* Universal Rewards Distributor */
     /**
-     * Encodes a call to the Bundler to claim rewards from the Universal Rewards Distributor.
+     * Encodes a call to the Adapter to claim rewards from the Universal Rewards Distributor.
+     * @param chainId The chain id for which to encode the call.
      * @param distributor The address of the distributor to claim rewards from.
      * @param account The address to claim rewards for.
      * @param reward The address of the reward token to claim.
@@ -544,292 +893,576 @@ export var BundlerAction;
      * @param proof The Merkle proof to claim the rewards.
      * @param skipRevert Whether to allow the claim to revert without making the whole multicall revert.
      */
-    function urdClaim(distributor, account, reward, amount, proof, skipRevert) {
-        return encodeFunctionData({
-            abi: urdBundlerAbi,
-            functionName: "urdClaim",
-            args: [distributor, account, reward, amount, proof, skipRevert],
-        });
+    function urdClaim(distributor, account, reward, amount, proof, skipRevert = true) {
+        return [
+            {
+                to: distributor,
+                data: encodeFunctionData({
+                    abi: universalRewardsDistributorAbi,
+                    functionName: "claim",
+                    args: [account, reward, amount, proof],
+                }),
+                value: 0n,
+                skipRevert,
+                callbackHash: zeroHash,
+            },
+        ];
     }
     BundlerAction.urdClaim = urdClaim;
     /* Wrapped Native */
     /**
-     * Encodes a call to the Bundler to wrap native tokens (ETH to WETH on ethereum, MATIC to WMATIC on polygon, etc).
+     * Encodes a call to the Adapter to wrap native tokens (ETH to WETH on ethereum, MATIC to WMATIC on polygon, etc).
+     * @param chainId The chain id for which to encode the call.
      * @param amount The amount of native tokens to wrap (in wei).
+     * @param recipient The address to send tokens to. Defaults to the chain's bundler3 general adapter.
      */
-    function wrapNative(amount) {
-        return encodeFunctionData({
-            abi: wNativeBundlerAbi,
-            functionName: "wrapNative",
-            args: [amount],
-        });
+    function wrapNative(chainId, amount, recipient) {
+        const { bundler3: { generalAdapter1 }, } = getChainAddresses(chainId);
+        recipient ??= generalAdapter1;
+        return [
+            {
+                to: generalAdapter1,
+                data: encodeFunctionData({
+                    abi: generalAdapter1Abi,
+                    functionName: "wrapNative",
+                    args: [amount, recipient],
+                }),
+                value: 0n,
+                skipRevert: false,
+                callbackHash: zeroHash,
+            },
+        ];
     }
     BundlerAction.wrapNative = wrapNative;
     /**
-     * Encodes a call to the Bundler to unwrap native tokens (WETH to ETH on ethereum, WMATIC to MATIC on polygon, etc).
+     * Encodes a call to the Adapter to unwrap native tokens (WETH to ETH on ethereum, WMATIC to MATIC on polygon, etc).
+     * @param chainId The chain id for which to encode the call.
      * @param amount The amount of native tokens to unwrap (in wei).
+     * @param recipient The address to send tokens to. Defaults to the chain's bundler3 general adapter.
      */
-    function unwrapNative(amount) {
-        return encodeFunctionData({
-            abi: wNativeBundlerAbi,
-            functionName: "unwrapNative",
-            args: [amount],
-        });
+    function unwrapNative(chainId, amount, recipient) {
+        const { bundler3: { generalAdapter1 }, } = getChainAddresses(chainId);
+        recipient ??= generalAdapter1;
+        return [
+            {
+                to: generalAdapter1,
+                data: encodeFunctionData({
+                    abi: generalAdapter1Abi,
+                    functionName: "unwrapNative",
+                    args: [amount, recipient],
+                }),
+                value: 0n,
+                skipRevert: false,
+                callbackHash: zeroHash,
+            },
+        ];
     }
     BundlerAction.unwrapNative = unwrapNative;
     /* stETH */
     /**
-     * Encodes a call to the Bundler to stake native tokens using Lido (ETH to stETH on ethereum).
+     * Encodes a call to the Adapter to stake native tokens using Lido (ETH to stETH on ethereum).
+     * @param chainId The chain id for which to encode the call.
      * @param amount The amount of native tokens to stake (in wei).
-     * @param minShares The minimum amount of shares to mint (protects the sender from unexpected slippage).
+     * @param maxSharePrice The maximum amount of wei to pay for minting 1 share (scaled by RAY).
      * @param referral The referral address to use.
+     * @param recipient The address to send stETH to. Defaults to the chain's bundler3 general adapter.
      */
-    function stakeEth(amount, minShares, referral) {
-        return encodeFunctionData({
-            abi: stEthBundlerAbi,
-            functionName: "stakeEth",
-            args: [amount, minShares, referral],
-        });
+    function stakeEth(chainId, amount, maxSharePrice, referral, recipient) {
+        const { bundler3: { generalAdapter1 }, } = getChainAddresses(chainId);
+        recipient ??= generalAdapter1;
+        return [
+            {
+                to: generalAdapter1,
+                data: encodeFunctionData({
+                    abi: ethereumGeneralAdapter1Abi,
+                    functionName: "stakeEth",
+                    args: [amount, maxSharePrice, referral, recipient],
+                }),
+                value: 0n,
+                skipRevert: false,
+                callbackHash: zeroHash,
+            },
+        ];
     }
     BundlerAction.stakeEth = stakeEth;
     /* Wrapped stETH */
     /**
-     * Encodes a call to the Bundler to wrap stETH (stETH to wstETH on ethereum).
+     * Encodes a call to the Adapter to wrap stETH (stETH to wstETH on ethereum).
+     * @param chainId The chain id for which to encode the call.
      * @param amount The amount of stETH to wrap (in wei).
+     * @param recipient The address to send wstETH to. Defaults to the chain's bundler3 general adapter.
      */
-    function wrapStEth(amount) {
-        return encodeFunctionData({
-            abi: stEthBundlerAbi,
-            functionName: "wrapStEth",
-            args: [amount],
-        });
+    function wrapStEth(chainId, amount, recipient) {
+        const { bundler3: { generalAdapter1 }, } = getChainAddresses(chainId);
+        recipient ??= generalAdapter1;
+        return [
+            {
+                to: generalAdapter1,
+                data: encodeFunctionData({
+                    abi: ethereumGeneralAdapter1Abi,
+                    functionName: "wrapStEth",
+                    args: [amount, recipient],
+                }),
+                value: 0n,
+                skipRevert: false,
+                callbackHash: zeroHash,
+            },
+        ];
     }
     BundlerAction.wrapStEth = wrapStEth;
     /**
-     * Encodes a call to the Bundler to unwrap wstETH (wstETH to stETH on ethereum).
+     * Encodes a call to the Adapter to unwrap wstETH (wstETH to stETH on ethereum).
+     * @param chainId The chain id for which to encode the call.
      * @param amount The amount of wstETH to unwrap (in wei).
+     * @param recipient The address to send stETH to. Defaults to the chain's bundler3 general adapter.
      */
-    function unwrapStEth(amount) {
-        return encodeFunctionData({
-            abi: stEthBundlerAbi,
-            functionName: "unwrapStEth",
-            args: [amount],
-        });
+    function unwrapStEth(chainId, amount, recipient) {
+        const { bundler3: { generalAdapter1 }, } = getChainAddresses(chainId);
+        recipient ??= generalAdapter1;
+        return [
+            {
+                to: generalAdapter1,
+                data: encodeFunctionData({
+                    abi: ethereumGeneralAdapter1Abi,
+                    functionName: "unwrapStEth",
+                    args: [amount, recipient],
+                }),
+                value: 0n,
+                skipRevert: false,
+                callbackHash: zeroHash,
+            },
+        ];
     }
     BundlerAction.unwrapStEth = unwrapStEth;
     /* AaveV2 */
     /**
-     * ! Only available on AaveV2MigrationBundler instances (not the main Bundler contract!).
-     * Encodes a call to the Bundler to repay a debt on AaveV2.
+     * Encodes a call to the Adapter to repay a debt on AaveV2.
+     * @param chainId The chain id for which to encode the call.
      * @param asset The debt asset to repay.
      * @param amount The amount of debt to repay.
+     * @param onBehalf The address on behalf of which to repay.
      * @param rateMode The interest rate mode used by the debt to repay.
      */
-    function aaveV2Repay(asset, amount, rateMode) {
-        return encodeFunctionData({
-            abi: aaveV2MigrationBundlerAbi,
-            functionName: "aaveV2Repay",
-            args: [asset, amount, rateMode],
-        });
+    function aaveV2Repay(chainId, asset, amount, onBehalf, rateMode = 1n) {
+        const { bundler3: { aaveV2MigrationAdapter }, } = getChainAddresses(chainId);
+        if (aaveV2MigrationAdapter == null)
+            throw new BundlerErrors.UnexpectedAction("aaveV2Repay", chainId);
+        return [
+            {
+                to: aaveV2MigrationAdapter,
+                data: encodeFunctionData({
+                    abi: aaveV2MigrationAdapterAbi,
+                    functionName: "aaveV2Repay",
+                    args: [asset, amount, rateMode, onBehalf],
+                }),
+                value: 0n,
+                skipRevert: false,
+                callbackHash: zeroHash,
+            },
+        ];
     }
     BundlerAction.aaveV2Repay = aaveV2Repay;
     /**
-     * ! Only available on AaveV2MigrationBundler instances (not the main Bundler contract!).
-     * Encodes a call to the Bundler to withdrawn from AaveV2.
+     * Encodes a call to the Adapter to withdrawn from AaveV2.
+     * @param chainId The chain id for which to encode the call.
      * @param asset The asset to withdraw.
      * @param amount The amount of asset to withdraw.
+     * @param recipient The recipient of ERC20 tokens. Defaults to the chain's bundler3 general adapter.
      */
-    function aaveV2Withdraw(asset, amount) {
-        return encodeFunctionData({
-            abi: aaveV2MigrationBundlerAbi,
-            functionName: "aaveV2Withdraw",
-            args: [asset, amount],
-        });
+    function aaveV2Withdraw(chainId, asset, amount, recipient) {
+        const { bundler3: { aaveV2MigrationAdapter }, } = getChainAddresses(chainId);
+        if (aaveV2MigrationAdapter == null)
+            throw new BundlerErrors.UnexpectedAction("aaveV2Withdraw", chainId);
+        recipient ??= aaveV2MigrationAdapter;
+        return [
+            {
+                to: aaveV2MigrationAdapter,
+                data: encodeFunctionData({
+                    abi: aaveV2MigrationAdapterAbi,
+                    functionName: "aaveV2Withdraw",
+                    args: [asset, amount, recipient],
+                }),
+                value: 0n,
+                skipRevert: false,
+                callbackHash: zeroHash,
+            },
+        ];
     }
     BundlerAction.aaveV2Withdraw = aaveV2Withdraw;
     /* AaveV3 */
     /**
-     * ! Only available on AaveV3MigrationBundler instances (not the main Bundler contract!).
-     * Encodes a call to the Bundler to repay a debt on AaveV3.
+     * Encodes a call to the Adapter to repay a debt on AaveV3.
+     * @param chainId The chain id for which to encode the call.
      * @param asset The debt asset to repay.
      * @param amount The amount of debt to repay.
+     * @param onBehalf The address on behalf of which to repay.
      * @param rateMode The interest rate mode used by the debt to repay.
      */
-    function aaveV3Repay(asset, amount, rateMode) {
-        return encodeFunctionData({
-            abi: aaveV3MigrationBundlerAbi,
-            functionName: "aaveV3Repay",
-            args: [asset, amount, rateMode],
-        });
+    function aaveV3Repay(chainId, asset, amount, onBehalf, rateMode = 1n) {
+        const { bundler3: { aaveV3CoreMigrationAdapter }, // TODO: choose between core & prime
+         } = getChainAddresses(chainId);
+        if (aaveV3CoreMigrationAdapter == null)
+            throw new BundlerErrors.UnexpectedAction("aaveV3Repay", chainId);
+        return [
+            {
+                to: aaveV3CoreMigrationAdapter,
+                data: encodeFunctionData({
+                    abi: aaveV3MigrationAdapterAbi,
+                    functionName: "aaveV3Repay",
+                    args: [asset, amount, rateMode, onBehalf],
+                }),
+                value: 0n,
+                skipRevert: false,
+                callbackHash: zeroHash,
+            },
+        ];
     }
     BundlerAction.aaveV3Repay = aaveV3Repay;
     /**
-     * ! Only available on AaveV3MigrationBundler instances (not the main Bundler contract!).
-     * Encodes a call to the Bundler to withdrawn from AaveV3.
+     * Encodes a call to the Adapter to withdrawn from AaveV3.
+     * @param chainId The chain id for which to encode the call.
      * @param asset The asset to withdraw.
      * @param amount The amount of asset to withdraw.
+     * @param recipient The recipient of ERC20 tokens. Defaults to the chain's bundler3 general adapter.
      */
-    function aaveV3Withdraw(asset, amount) {
-        return encodeFunctionData({
-            abi: aaveV3MigrationBundlerAbi,
-            functionName: "aaveV3Withdraw",
-            args: [asset, amount],
-        });
+    function aaveV3Withdraw(chainId, asset, amount, recipient) {
+        const { bundler3: { aaveV3CoreMigrationAdapter }, // TODO: choose between core & prime
+         } = getChainAddresses(chainId);
+        if (aaveV3CoreMigrationAdapter == null)
+            throw new BundlerErrors.UnexpectedAction("aaveV3Withdraw", chainId);
+        recipient ??= aaveV3CoreMigrationAdapter;
+        return [
+            {
+                to: aaveV3CoreMigrationAdapter,
+                data: encodeFunctionData({
+                    abi: aaveV3MigrationAdapterAbi,
+                    functionName: "aaveV3Withdraw",
+                    args: [asset, amount, recipient],
+                }),
+                value: 0n,
+                skipRevert: false,
+                callbackHash: zeroHash,
+            },
+        ];
     }
     BundlerAction.aaveV3Withdraw = aaveV3Withdraw;
     /* AaveV3 Optimizer */
     /**
-     * ! Only available on AaveV3OptimizerMigrationBundler instances (not the main Bundler contract!).
-     * Encodes a call to the Bundler to repay a debt on Morpho's AaveV3Optimizer.
+     * Encodes a call to the Adapter to repay a debt on Morpho's AaveV3Optimizer.
+     * @param chainId The chain id for which to encode the call.
      * @param underlying The underlying debt asset to repay.
      * @param amount The amount of debt to repay.
-     * @param maxIterations The maximum amount of iterations to use for the repayment.
+     * @param onBehalf The address on behalf of which to repay.
      */
-    function aaveV3OptimizerRepay(underlying, amount) {
-        return encodeFunctionData({
-            abi: aaveV3OptimizerMigrationBundlerAbi,
-            functionName: "aaveV3OptimizerRepay",
-            args: [underlying, amount],
-        });
+    function aaveV3OptimizerRepay(chainId, underlying, amount, onBehalf) {
+        const { bundler3: { aaveV3OptimizerMigrationAdapter }, } = getChainAddresses(chainId);
+        if (aaveV3OptimizerMigrationAdapter == null)
+            throw new BundlerErrors.UnexpectedAction("aaveV3OptimizerRepay", chainId);
+        return [
+            {
+                to: aaveV3OptimizerMigrationAdapter,
+                data: encodeFunctionData({
+                    abi: aaveV3OptimizerMigrationAdapterAbi,
+                    functionName: "aaveV3OptimizerRepay",
+                    args: [underlying, amount, onBehalf],
+                }),
+                value: 0n,
+                skipRevert: false,
+                callbackHash: zeroHash,
+            },
+        ];
     }
     BundlerAction.aaveV3OptimizerRepay = aaveV3OptimizerRepay;
     /**
-     * ! Only available on AaveV3OptimizerMigrationBundler instances (not the main Bundler contract!).
-     * Encodes a call to the Bundler to withdraw from Morpho's AaveV3Optimizer.
+     * Encodes a call to the Adapter to withdraw from Morpho's AaveV3Optimizer.
+     * @param chainId The chain id for which to encode the call.
      * @param underlying The underlying asset to withdraw.
      * @param amount The amount to withdraw.
      * @param maxIterations The maximum amount of iterations to use for the withdrawal.
+     * @param recipient The recipient of ERC20 tokens. Defaults to the chain's bundler3 general adapter.
      */
-    function aaveV3OptimizerWithdraw(underlying, amount, maxIterations) {
-        return encodeFunctionData({
-            abi: aaveV3OptimizerMigrationBundlerAbi,
-            functionName: "aaveV3OptimizerWithdraw",
-            args: [underlying, amount, maxIterations],
-        });
+    function aaveV3OptimizerWithdraw(chainId, underlying, amount, maxIterations, recipient) {
+        const { bundler3: { aaveV3OptimizerMigrationAdapter }, } = getChainAddresses(chainId);
+        if (aaveV3OptimizerMigrationAdapter == null)
+            throw new BundlerErrors.UnexpectedAction("aaveV3OptimizerWithdraw", chainId);
+        recipient ??= aaveV3OptimizerMigrationAdapter;
+        return [
+            {
+                to: aaveV3OptimizerMigrationAdapter,
+                data: encodeFunctionData({
+                    abi: aaveV3OptimizerMigrationAdapterAbi,
+                    functionName: "aaveV3OptimizerWithdraw",
+                    args: [underlying, amount, maxIterations, recipient],
+                }),
+                value: 0n,
+                skipRevert: false,
+                callbackHash: zeroHash,
+            },
+        ];
     }
     BundlerAction.aaveV3OptimizerWithdraw = aaveV3OptimizerWithdraw;
     /**
-     * ! Only available on AaveV3OptimizerMigrationBundler instances (not the main Bundler contract!).
-     * Encodes a call to the Bundler to withdraw collateral from Morpho's AaveV3Optimizer.
+     * Encodes a call to the Adapter to withdraw collateral from Morpho's AaveV3Optimizer.
+     * @param chainId The chain id for which to encode the call.
      * @param underlying The underlying asset to withdraw.
      * @param amount The amount to withdraw.
+     * @param recipient The recipient of ERC20 tokens. Defaults to the chain's bundler3 general adapter.
      */
-    function aaveV3OptimizerWithdrawCollateral(underlying, amount) {
-        return encodeFunctionData({
-            abi: aaveV3OptimizerMigrationBundlerAbi,
-            functionName: "aaveV3OptimizerWithdrawCollateral",
-            args: [underlying, amount],
-        });
+    function aaveV3OptimizerWithdrawCollateral(chainId, underlying, amount, recipient) {
+        const { bundler3: { aaveV3OptimizerMigrationAdapter }, } = getChainAddresses(chainId);
+        if (aaveV3OptimizerMigrationAdapter == null)
+            throw new BundlerErrors.UnexpectedAction("aaveV3OptimizerWithdrawCollateral", chainId);
+        recipient ??= aaveV3OptimizerMigrationAdapter;
+        return [
+            {
+                to: aaveV3OptimizerMigrationAdapter,
+                data: encodeFunctionData({
+                    abi: aaveV3OptimizerMigrationAdapterAbi,
+                    functionName: "aaveV3OptimizerWithdrawCollateral",
+                    args: [underlying, amount, recipient],
+                }),
+                value: 0n,
+                skipRevert: false,
+                callbackHash: zeroHash,
+            },
+        ];
     }
     BundlerAction.aaveV3OptimizerWithdrawCollateral = aaveV3OptimizerWithdrawCollateral;
     /**
-     * ! Only available on AaveV3OptimizerMigrationBundler instances (not the main Bundler contract!).
-     * Encodes a call to the Bundler to approve the Bundler as the sender's manager on Morpho's AaveV3Optimizer.
+     * Encodes a call to the Adapter to approve the Bundler as the sender's manager on Morpho's AaveV3Optimizer.
+     * @param chainId The chain id for which to encode the call.
+     * @param owner The owner of the AaveV3Optimizer position.
      * @param isApproved Whether the manager is approved.
      * @param nonce The nonce used to sign.
      * @param deadline The timestamp until which the signature is valid.
      * @param signature The Ethers signature to submit.
+     * @param manager The address of the manager to approve. Defaults to the chain's bundler3 AaveV3OptimizerMigrationAdapter.
      * @param skipRevert Whether to allow the signature to revert without making the whole multicall revert.
      */
-    function aaveV3OptimizerApproveManagerWithSig(isApproved, nonce, deadline, signature, skipRevert) {
+    function aaveV3OptimizerApproveManagerWithSig(chainId, owner, isApproved, nonce, deadline, signature, manager, skipRevert = true) {
+        const { aaveV3Optimizer, bundler3: { aaveV3OptimizerMigrationAdapter }, } = getChainAddresses(chainId);
+        if (aaveV3Optimizer == null || aaveV3OptimizerMigrationAdapter == null)
+            throw new BundlerErrors.UnexpectedAction("aaveV3OptimizerApproveManagerWithSig", chainId);
+        manager ??= aaveV3OptimizerMigrationAdapter;
         const { r, s, yParity } = parseSignature(signature);
-        return encodeFunctionData({
-            abi: aaveV3OptimizerMigrationBundlerAbi,
-            functionName: "aaveV3OptimizerApproveManagerWithSig",
-            args: [
-                isApproved,
-                nonce,
-                deadline,
-                { v: yParity + 27, r, s },
+        return [
+            {
+                to: aaveV3Optimizer,
+                data: encodeFunctionData({
+                    abi: [
+                        {
+                            inputs: [
+                                { name: "delegator", type: "address" },
+                                { name: "manager", type: "address" },
+                                { name: "isAllowed", type: "bool" },
+                                { name: "nonce", type: "uint256" },
+                                { name: "deadline", type: "uint256" },
+                                {
+                                    components: [
+                                        { name: "v", type: "uint8" },
+                                        { name: "r", type: "bytes32" },
+                                        { name: "s", type: "bytes32" },
+                                    ],
+                                    internalType: "struct Types.Signature",
+                                    name: "signature",
+                                    type: "tuple",
+                                },
+                            ],
+                            name: "approveManagerWithSig",
+                            outputs: [],
+                            stateMutability: "nonpayable",
+                            type: "function",
+                        },
+                    ],
+                    functionName: "approveManagerWithSig",
+                    args: [
+                        owner,
+                        manager,
+                        isApproved,
+                        nonce,
+                        deadline,
+                        { v: yParity + 27, r, s },
+                    ],
+                }),
+                value: 0n,
                 skipRevert,
-            ],
-        });
+                callbackHash: zeroHash,
+            },
+        ];
     }
     BundlerAction.aaveV3OptimizerApproveManagerWithSig = aaveV3OptimizerApproveManagerWithSig;
     /* CompoundV2 */
     /**
-     * ! Only available on CompoundV2MigrationBundler instances (not the main Bundler contract!).
-     * Encodes a call to the Bundler to repay a debt on CompoundV2.
+     * Encodes a call to the Adapter to repay a debt on CompoundV2.
+     * @param chainId The chain id for which to encode the call.
      * @param cToken The cToken on which to repay the debt.
      * @param amount The amount of debt to repay.
+     * @param recipient The recipient of ERC20 tokens. Defaults to the chain's bundler3 general adapter.
      */
-    function compoundV2Repay(cToken, amount) {
-        return encodeFunctionData({
-            abi: compoundV2MigrationBundlerAbi,
-            functionName: "compoundV2Repay",
-            args: [cToken, amount],
-        });
+    function compoundV2Repay(chainId, cToken, amount, recipient) {
+        const { cEth, bundler3: { compoundV2MigrationAdapter }, } = getChainAddresses(chainId);
+        if (cEth == null || compoundV2MigrationAdapter == null)
+            throw new BundlerErrors.UnexpectedAction("compoundV2Repay", chainId);
+        const isEth = cToken === cEth;
+        recipient ??= compoundV2MigrationAdapter;
+        return [
+            {
+                to: compoundV2MigrationAdapter,
+                data: isEth
+                    ? encodeFunctionData({
+                        abi: compoundV2MigrationAdapterAbi,
+                        functionName: "compoundV2RepayEth",
+                        args: [amount, recipient],
+                    })
+                    : encodeFunctionData({
+                        abi: compoundV2MigrationAdapterAbi,
+                        functionName: "compoundV2RepayErc20",
+                        args: [cToken, amount, recipient],
+                    }),
+                value: isEth ? amount : 0n,
+                skipRevert: false,
+                callbackHash: zeroHash,
+            },
+        ];
     }
     BundlerAction.compoundV2Repay = compoundV2Repay;
     /**
-     * ! Only available on CompoundV2MigrationBundler instances (not the main Bundler contract!).
-     * Encodes a call to the Bundler to withdraw collateral from CompoundV2.
+     * Encodes a call to the Adapter to withdraw collateral from CompoundV2.
+     * @param chainId The chain id for which to encode the call.
      * @param cToken The cToken on which to withdraw.
      * @param amount The amount to withdraw.
+     * @param recipient The recipient of ERC20 tokens. Defaults to the chain's bundler3 general adapter.
      */
-    function compoundV2Redeem(cToken, amount) {
-        return encodeFunctionData({
-            abi: compoundV2MigrationBundlerAbi,
-            functionName: "compoundV2Redeem",
-            args: [cToken, amount],
-        });
+    function compoundV2Redeem(chainId, cToken, amount, recipient) {
+        const { cEth, bundler3: { compoundV2MigrationAdapter }, } = getChainAddresses(chainId);
+        if (cEth == null || compoundV2MigrationAdapter == null)
+            throw new BundlerErrors.UnexpectedAction("compoundV2Repay", chainId);
+        const isEth = cToken === cEth;
+        recipient ??= compoundV2MigrationAdapter;
+        return [
+            {
+                to: compoundV2MigrationAdapter,
+                data: isEth
+                    ? encodeFunctionData({
+                        abi: compoundV2MigrationAdapterAbi,
+                        functionName: "compoundV2RedeemEth",
+                        args: [amount, recipient],
+                    })
+                    : encodeFunctionData({
+                        abi: compoundV2MigrationAdapterAbi,
+                        functionName: "compoundV2RedeemErc20",
+                        args: [cToken, amount, recipient],
+                    }),
+                value: 0n,
+                skipRevert: false,
+                callbackHash: zeroHash,
+            },
+        ];
     }
     BundlerAction.compoundV2Redeem = compoundV2Redeem;
     /* CompoundV3 */
     /**
-     * ! Only available on CompoundV3MigrationBundler instances (not the main Bundler contract!).
-     * Encodes a call to the Bundler to repay a debt on CompoundV3.
+     * Encodes a call to the Adapter to repay a debt on CompoundV3.
+     * @param chainId The chain id for which to encode the call.
      * @param instance The CompoundV3 instance on which to repay the debt.
      * @param amount The amount of debt to repay.
+     * @param onBehalf The address on behalf of which to repay.
      */
-    function compoundV3Repay(instance, amount) {
-        return encodeFunctionData({
-            abi: compoundV3MigrationBundlerAbi,
-            functionName: "compoundV3Repay",
-            args: [instance, amount],
-        });
+    function compoundV3Repay(chainId, instance, amount, onBehalf) {
+        const { bundler3: { compoundV3MigrationAdapter }, } = getChainAddresses(chainId);
+        if (compoundV3MigrationAdapter == null)
+            throw new BundlerErrors.UnexpectedAction("compoundV3Repay", chainId);
+        return [
+            {
+                to: compoundV3MigrationAdapter,
+                data: encodeFunctionData({
+                    abi: compoundV3MigrationAdapterAbi,
+                    functionName: "compoundV3Repay",
+                    args: [instance, amount, onBehalf],
+                }),
+                value: 0n,
+                skipRevert: false,
+                callbackHash: zeroHash,
+            },
+        ];
     }
     BundlerAction.compoundV3Repay = compoundV3Repay;
     /**
-     * ! Only available on CompoundV3MigrationBundler instances (not the main Bundler contract!).
-     * Encodes a call to the Bundler to withdraw collateral from CompoundV3.
+     * Encodes a call to the Adapter to withdraw collateral from CompoundV3.
+     * @param chainId The chain id for which to encode the call.
      * @param instance The CompoundV3 instance on which to withdraw.
+     * @param asset The asset to withdraw.
      * @param amount The amount to withdraw.
+     * @param recipient The recipient of ERC20 tokens. Defaults to the chain's bundler3 general adapter.
      */
-    function compoundV3WithdrawFrom(instance, asset, amount) {
-        return encodeFunctionData({
-            abi: compoundV3MigrationBundlerAbi,
-            functionName: "compoundV3WithdrawFrom",
-            args: [instance, asset, amount],
-        });
+    function compoundV3WithdrawFrom(chainId, instance, asset, amount, recipient) {
+        const { bundler3: { compoundV3MigrationAdapter }, } = getChainAddresses(chainId);
+        if (compoundV3MigrationAdapter == null)
+            throw new BundlerErrors.UnexpectedAction("compoundV3WithdrawFrom", chainId);
+        recipient ??= compoundV3MigrationAdapter;
+        return [
+            {
+                to: compoundV3MigrationAdapter,
+                data: encodeFunctionData({
+                    abi: compoundV3MigrationAdapterAbi,
+                    functionName: "compoundV3WithdrawFrom",
+                    args: [instance, asset, amount, recipient],
+                }),
+                value: 0n,
+                skipRevert: false,
+                callbackHash: zeroHash,
+            },
+        ];
     }
     BundlerAction.compoundV3WithdrawFrom = compoundV3WithdrawFrom;
     /**
-     * ! Only available on CompoundV3MigrationBundler instances (not the main Bundler contract!).
-     * Encodes a call to the Bundler to allow the Bundler to act on the sender's position on CompoundV3.
+     * Encodes a call to the Adapter to allow the Bundler to act on the sender's position on CompoundV3.
+     * @param chainId The chain id for which to encode the call.
      * @param instance The CompoundV3 instance on which to submit the signature.
+     * @param owner The owner of the CompoundV3 position.
      * @param isAllowed Whether the manager is allowed.
      * @param nonce The nonce used to sign.
      * @param expiry The timestamp until which the signature is valid.
      * @param signature The Ethers signature to submit.
+     * @param manager The address of the manager to approve. Defaults to the chain's bundler3 CompoundV3MigrationAdapter.
      * @param skipRevert Whether to allow the signature to revert without making the whole multicall revert.
      */
-    function compoundV3AllowBySig(instance, isAllowed, nonce, expiry, signature, skipRevert) {
+    function compoundV3AllowBySig(chainId, instance, owner, isAllowed, nonce, expiry, signature, manager, skipRevert = true) {
+        const { bundler3: { compoundV3MigrationAdapter }, } = getChainAddresses(chainId);
+        if (compoundV3MigrationAdapter == null)
+            throw new BundlerErrors.UnexpectedAction("compoundV3AllowBySig", chainId);
         const { r, s, yParity } = parseSignature(signature);
-        return encodeFunctionData({
-            abi: compoundV3MigrationBundlerAbi,
-            functionName: "compoundV3AllowBySig",
-            args: [
-                instance,
-                isAllowed,
-                nonce,
-                expiry,
-                yParity + 27,
-                r,
-                s,
+        manager ??= compoundV3MigrationAdapter;
+        return [
+            {
+                to: instance,
+                data: encodeFunctionData({
+                    abi: [
+                        {
+                            inputs: [
+                                { name: "owner", type: "address" },
+                                { name: "manager", type: "address" },
+                                { name: "isAllowed_", type: "bool" },
+                                { name: "nonce", type: "uint256" },
+                                { name: "expiry", type: "uint256" },
+                                { name: "v", type: "uint8" },
+                                { name: "r", type: "bytes32" },
+                                { name: "s", type: "bytes32" },
+                            ],
+                            name: "allowBySig",
+                            outputs: [],
+                            stateMutability: "nonpayable",
+                            type: "function",
+                        },
+                    ],
+                    functionName: "allowBySig",
+                    args: [owner, manager, isAllowed, nonce, expiry, yParity + 27, r, s],
+                }),
+                value: 0n,
                 skipRevert,
-            ],
-        });
+                callbackHash: zeroHash,
+            },
+        ];
     }
     BundlerAction.compoundV3AllowBySig = compoundV3AllowBySig;
 })(BundlerAction || (BundlerAction = {}));