@morpho-org/bundler-sdk-viem 3.0.0-next.9 → 3.0.1

package/lib/ActionBundle.d.ts

@@ -19,10 +19,12 @@ export declare class ActionBundle<TR extends {
         data: Hex;
     };
 } = TransactionRequirement, SR extends SignatureRequirement = SignatureRequirement> {
-    readonly steps: SimulationResult;
     readonly actions: Action[];
     readonly requirements: ActionBundleRequirements<TR, SR>;
+    readonly steps?: SimulationResult;
+    readonly chainId: number;
     constructor(steps: SimulationResult, actions?: Action[], requirements?: ActionBundleRequirements<TR, SR>);
+    constructor(chainId: number, actions?: Action[], requirements?: ActionBundleRequirements<TR, SR>);
     tx(): {
         to: `0x${string}`;
         value: bigint;

package/lib/ActionBundle.js

@@ -1,5 +1,8 @@
-import { BundlerAction } from "./BundlerAction.js";
-export class ActionBundleRequirements {
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ActionBundle = exports.ActionBundleRequirements = void 0;
+const BundlerAction_js_1 = require("./BundlerAction.js");
+class ActionBundleRequirements {
     txs;
     signatures;
     constructor(txs = [], signatures = []) {
@@ -10,19 +13,28 @@ export class ActionBundleRequirements {
         return Promise.all(this.signatures.map((requirement) => requirement.sign(client, account)));
     }
 }
-export class ActionBundle {
-    steps;
+exports.ActionBundleRequirements = ActionBundleRequirements;
+class ActionBundle {
     actions;
     requirements;
-    constructor(steps, actions = [], requirements = new ActionBundleRequirements()) {
-        this.steps = steps;
+    steps;
+    chainId;
+    constructor(stepsOrChainId, actions = [], requirements = new ActionBundleRequirements()) {
         this.actions = actions;
         this.requirements = requirements;
+        if (typeof stepsOrChainId === "number") {
+            this.chainId = stepsOrChainId;
+        }
+        else {
+            this.steps = stepsOrChainId;
+            this.chainId = stepsOrChainId[0].chainId;
+        }
     }
     tx() {
-        return BundlerAction.encodeBundle(this.steps[0].chainId, this.actions);
+        return BundlerAction_js_1.BundlerAction.encodeBundle(this.chainId, this.actions);
     }
     txs() {
         return this.requirements.txs.map(({ tx }) => tx).concat([this.tx()]);
     }
 }
+exports.ActionBundle = ActionBundle;

package/lib/BundlerAction.d.ts

@@ -19,135 +19,144 @@ export declare namespace BundlerAction {
     };
     function encode(chainId: ChainId, { type, args }: Action): BundlerCall[];
     /**
-     * Encodes a call to the Adapter to transfer native tokens (ETH on ethereum, MATIC on polygon, etc).
+     * Encodes a call to the GeneralAdapter1 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).
+     * @param skipRevert Whether to allow the transfer to revert without making the whole bundler revert. Defaults to false.
      */
-    function nativeTransfer(chainId: ChainId, owner: Address, recipient: Address, amount: bigint): BundlerCall[];
+    function nativeTransfer(chainId: ChainId, owner: Address, recipient: Address, amount: bigint, skipRevert?: boolean): BundlerCall[];
     /**
-     * Encodes a call to the Adapter to transfer ERC20 tokens.
+     * Encodes a call to the requested 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.
+     * @param adapter The address of the adapter to use.
+     * @param skipRevert Whether to allow the transfer to revert without making the whole bundler revert. Defaults to false.
      */
-    function erc20Transfer(chainId: ChainId, asset: Address, recipient: Address, amount: bigint, adapter?: Address): BundlerCall[];
+    function erc20Transfer(asset: Address, recipient: Address, amount: bigint, adapter: Address, skipRevert?: boolean): BundlerCall[];
     /**
-     * Encodes a call to the Adapter to transfer ERC20 tokens from the sender to the Bundler.
+     * Encodes a call to the GeneralAdapter1 to transfer ERC20 tokens with `transferFrom`.
      * @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.
+     * @param recipient The recipient of ERC20 tokens.
+     * @param skipRevert Whether to allow the transfer to revert without making the whole bundler revert. Defaults to false.
      */
-    function erc20TransferFrom(chainId: ChainId, asset: Address, amount: bigint, recipient?: Address): BundlerCall[];
+    function erc20TransferFrom(chainId: ChainId, asset: Address, amount: bigint, recipient: Address, skipRevert?: boolean): BundlerCall[];
     /**
-     * Encodes a call to the Adapter to permit an ERC20 token.
+     * Encodes a call to the GeneralAdapter1 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.
+     * @param skipRevert Whether to allow the permit to revert without making the whole bundle revert. Defaults to true.
      */
-    function permit(chainId: ChainId, owner: Address, asset: Address, amount: bigint, deadline: bigint, signature: Hex, spender?: Address, skipRevert?: boolean): BundlerCall[];
+    function permit(chainId: ChainId, owner: Address, asset: Address, amount: bigint, deadline: bigint, signature: Hex, skipRevert?: boolean): BundlerCall[];
     /**
-     * Encodes a call to the Adapter to permit DAI.
+     * Encodes a call to the GeneralAdapter1 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.
+     * @param skipRevert Whether to allow the permit to revert without making the whole bundle revert.
      */
-    function permitDai(chainId: ChainId, owner: Address, nonce: bigint, expiry: bigint, allowed: boolean, signature: Hex, spender?: Address, skipRevert?: boolean): BundlerCall[];
+    function permitDai(chainId: ChainId, owner: Address, nonce: bigint, expiry: bigint, allowed: boolean, signature: Hex, skipRevert?: boolean): BundlerCall[];
     /**
-     * Encodes a call to the Adapter to permit ERC20 tokens via Permit2.
+     * Encodes a call to permit the chain's GeneralAdapter1 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.
+     * @param skipRevert Whether to allow the permit to revert without making the whole bundle revert. Defaults to true.
      */
     function approve2(chainId: ChainId, owner: Address, permitSingle: Permit2PermitSingle, signature: Hex, skipRevert?: boolean): BundlerCall[];
     /**
-     * Encodes a call to the Adapter to transfer ERC20 tokens via Permit2 from the sender to the Bundler.
+     * Encodes a call to the GeneralAdapter1 to transfer ERC20 tokens via Permit2.
      * @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.
+     * @param recipient The recipient of ERC20 tokens.
+     * @param skipRevert Whether to allow the transfer to revert without making the whole bundler revert. Defaults to false.
      */
-    function transferFrom2(chainId: ChainId, asset: Address, owner: Address, amount: bigint, recipient?: Address): BundlerCall[];
+    function transferFrom2(chainId: ChainId, asset: Address, amount: bigint, recipient: Address, skipRevert?: boolean): BundlerCall[];
     /**
-     * Encodes a call to the Adapter to wrap ERC20 tokens via the provided ERC20Wrapper.
+     * Encodes a call to the GeneralAdapter1 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.
+     * @param skipRevert Whether to allow the transfer to revert without making the whole bundler revert. Defaults to false.
      */
-    function erc20WrapperDepositFor(chainId: ChainId, wrapper: Address, underlying: Address, amount: bigint): BundlerCall[];
+    function erc20WrapperDepositFor(chainId: ChainId, wrapper: Address, underlying: Address, amount: bigint, skipRevert?: boolean): BundlerCall[];
     /**
-     * Encodes a call to the Adapter to unwrap ERC20 tokens from the provided ERC20Wrapper.
+     * Encodes a call to the GeneralAdapter1 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.
+     * @param skipRevert Whether to allow the transfer to revert without making the whole bundler revert. Defaults to false.
      */
-    function erc20WrapperWithdrawTo(chainId: ChainId, wrapper: Address, receiver: Address, amount: bigint): BundlerCall[];
+    function erc20WrapperWithdrawTo(chainId: ChainId, wrapper: Address, receiver: Address, amount: bigint, skipRevert?: boolean): BundlerCall[];
     /**
-     * Encodes a call to the Adapter to mint shares of the provided ERC4626 vault.
+     * Encodes a call to the GeneralAdapter1 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 maxSharePrice The maximum amount of assets to pay to get 1 share (scaled by RAY).
      * @param receiver The address to send the shares to.
+     * @param skipRevert Whether to allow the transfer to revert without making the whole bundler revert. Defaults to false.
      */
-    function erc4626Mint(chainId: ChainId, erc4626: Address, shares: bigint, maxSharePrice: bigint, receiver: Address): BundlerCall[];
+    function erc4626Mint(chainId: ChainId, erc4626: Address, shares: bigint, maxSharePrice: bigint, receiver: Address, skipRevert?: boolean): BundlerCall[];
     /**
-     * Encodes a call to the Adapter to deposit assets into the provided ERC4626 vault.
+     * Encodes a call to the GeneralAdapter1 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 maxSharePrice The maximum amount of assets to pay to get 1 share (scaled by RAY).
      * @param receiver The address to send the shares to.
+     * @param skipRevert Whether to allow the transfer to revert without making the whole bundler revert. Defaults to false.
      */
-    function erc4626Deposit(chainId: ChainId, erc4626: Address, assets: bigint, maxSharePrice: bigint, receiver: Address): BundlerCall[];
+    function erc4626Deposit(chainId: ChainId, erc4626: Address, assets: bigint, maxSharePrice: bigint, receiver: Address, skipRevert?: boolean): BundlerCall[];
     /**
-     * Encodes a call to the Adapter to withdraw assets from the provided ERC4626 vault.
+     * Encodes a call to the GeneralAdapter1 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 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.
+     * @param skipRevert Whether to allow the transfer to revert without making the whole bundler revert. Defaults to false.
      */
-    function erc4626Withdraw(chainId: ChainId, erc4626: Address, assets: bigint, minSharePrice: bigint, receiver: Address, owner: Address): BundlerCall[];
+    function erc4626Withdraw(chainId: ChainId, erc4626: Address, assets: bigint, minSharePrice: bigint, receiver: Address, owner: Address, skipRevert?: boolean): BundlerCall[];
     /**
-     * Encodes a call to the Adapter to redeem shares from the provided ERC4626 vault.
+     * Encodes a call to the GeneralAdapter1 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 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.
+     * @param skipRevert Whether to allow the transfer to revert without making the whole bundler revert. Defaults to false.
      */
-    function erc4626Redeem(chainId: ChainId, erc4626: Address, shares: bigint, minSharePrice: bigint, receiver: Address, owner: Address): BundlerCall[];
+    function erc4626Redeem(chainId: ChainId, erc4626: Address, shares: bigint, minSharePrice: bigint, receiver: Address, owner: Address, skipRevert?: boolean): BundlerCall[];
     /**
-     * Encodes a call to the Adapter to authorize an account on Morpho Blue.
+     * Encodes a call 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.
+     * @param skipRevert Whether to allow the authorization call to revert without making the whole bundle revert. Defaults to true.
      */
     function morphoSetAuthorizationWithSig(chainId: ChainId, authorization: Authorization, signature: Hex, skipRevert?: boolean): BundlerCall[];
     /**
-     * Encodes a call to the Adapter to supply to a Morpho Blue market.
+     * Encodes a call to the GeneralAdapter1 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.
@@ -155,29 +164,32 @@ export declare namespace BundlerAction {
      * @param slippageAmount The maximum (resp. minimum) amount of assets (resp. supply shares) to supply (resp. mint) (protects the sender from unexpected slippage).
      * @param onBehalf The address to supply on behalf of.
      * @param callbackCalls The array of calls to execute inside Morpho Blue's `onMorphoSupply` callback.
+     * @param skipRevert Whether to allow the transfer to revert without making the whole bundler revert. Defaults to false.
      */
-    function morphoSupply(chainId: ChainId, market: InputMarketParams, assets: bigint, shares: bigint, slippageAmount: bigint, onBehalf: Address, callbackCalls: BundlerCall[]): BundlerCall[];
+    function morphoSupply(chainId: ChainId, market: InputMarketParams, assets: bigint, shares: bigint, slippageAmount: bigint, onBehalf: Address, callbackCalls: BundlerCall[], skipRevert?: boolean): BundlerCall[];
     /**
-     * Encodes a call to the Adapter to supply collateral to a Morpho Blue market.
+     * Encodes a call to the GeneralAdapter1 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.
+     * @param skipRevert Whether to allow the transfer to revert without making the whole bundler revert. Defaults to false.
      */
-    function morphoSupplyCollateral(chainId: ChainId, market: InputMarketParams, assets: bigint, onBehalf: Address, callbackCalls: BundlerCall[]): BundlerCall[];
+    function morphoSupplyCollateral(chainId: ChainId, market: InputMarketParams, assets: bigint, onBehalf: Address, callbackCalls: BundlerCall[], skipRevert?: boolean): BundlerCall[];
     /**
-     * Encodes a call to the Adapter to borrow from a Morpho Blue market.
+     * Encodes a call to the GeneralAdapter1 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.
+     * @param skipRevert Whether to allow the transfer to revert without making the whole bundler revert. Defaults to false.
      */
-    function morphoBorrow(chainId: ChainId, market: InputMarketParams, assets: bigint, shares: bigint, slippageAmount: bigint, receiver: Address): BundlerCall[];
+    function morphoBorrow(chainId: ChainId, market: InputMarketParams, assets: bigint, shares: bigint, slippageAmount: bigint, receiver: Address, skipRevert?: boolean): BundlerCall[];
     /**
-     * Encodes a call to the Adapter to repay to a Morpho Blue market.
+     * Encodes a call to the GeneralAdapter1 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.
@@ -185,197 +197,219 @@ export declare namespace BundlerAction {
      * @param slippageAmount The maximum (resp. minimum) amount of assets (resp. borrow shares) to repay (resp. redeem) (protects the sender from unexpected slippage).
      * @param onBehalf The address to repay on behalf of.
      * @param callbackCalls The array of calls to execute inside Morpho Blue's `onMorphoSupply` callback.
+     * @param skipRevert Whether to allow the transfer to revert without making the whole bundler revert. Defaults to false.
      */
-    function morphoRepay(chainId: ChainId, market: InputMarketParams, assets: bigint, shares: bigint, slippageAmount: bigint, onBehalf: Address, callbackCalls: BundlerCall[]): BundlerCall[];
+    function morphoRepay(chainId: ChainId, market: InputMarketParams, assets: bigint, shares: bigint, slippageAmount: bigint, onBehalf: Address, callbackCalls: BundlerCall[], skipRevert?: boolean): BundlerCall[];
     /**
-     * Encodes a call to the Adapter to withdraw from a Morpho Blue market.
+     * Encodes a call to the GeneralAdapter1 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.
+     * @param skipRevert Whether to allow the transfer to revert without making the whole bundler revert. Defaults to false.
      */
-    function morphoWithdraw(chainId: ChainId, market: InputMarketParams, assets: bigint, shares: bigint, slippageAmount: bigint, receiver: Address): BundlerCall[];
+    function morphoWithdraw(chainId: ChainId, market: InputMarketParams, assets: bigint, shares: bigint, slippageAmount: bigint, receiver: Address, skipRevert?: boolean): BundlerCall[];
     /**
-     * Encodes a call to the Adapter to withdraw collateral from a Morpho Blue market.
+     * Encodes a call to the GeneralAdapter1 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.
+     * @param skipRevert Whether to allow the transfer to revert without making the whole bundler revert. Defaults to false.
      */
-    function morphoWithdrawCollateral(chainId: ChainId, market: InputMarketParams, assets: bigint, receiver: Address): BundlerCall[];
+    function morphoWithdrawCollateral(chainId: ChainId, market: InputMarketParams, assets: bigint, receiver: Address, skipRevert?: boolean): BundlerCall[];
     /**
-     * Encodes a call to the Adapter to flash loan from Morpho Blue.
+     * 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 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[]): BundlerCall[];
+    function morphoFlashLoan(chainId: ChainId, asset: Address, amount: bigint, callbackCalls: BundlerCall[], skipRevert?: boolean): BundlerCall[];
     /**
-     * Encodes a call to the Adapter to trigger a public reallocation on the PublicAllocator.
+     * Encodes a call 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 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.
+     * @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): BundlerCall[];
+    function publicAllocatorReallocateTo(chainId: ChainId, vault: Address, fee: bigint, withdrawals: InputReallocation[], supplyMarketParams: InputMarketParams, skipRevert?: boolean): BundlerCall[];
     /**
-     * Encodes a call to the Adapter to claim rewards from the Universal Rewards Distributor.
+     * Encodes a call to the Universal Rewards Distributor to claim rewards.
      * @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.
      * @param amount The amount of rewards to claim.
      * @param proof The Merkle proof to claim the rewards.
-     * @param skipRevert Whether to allow the claim to revert without making the whole multicall revert.
+     * @param skipRevert Whether to allow the claim to revert without making the whole bundle revert. Defaults to true.
      */
     function urdClaim(distributor: Address, account: Address, reward: Address, amount: bigint, proof: Hex[], skipRevert?: boolean): BundlerCall[];
     /**
-     * Encodes a call to the Adapter to wrap native tokens (ETH to WETH on ethereum, MATIC to WMATIC on polygon, etc).
+     * Encodes a call to the GeneralAdapter1 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.
+     * @param recipient The address to send tokens to.
+     * @param skipRevert Whether to allow the transfer to revert without making the whole bundler revert. Defaults to false.
      */
-    function wrapNative(chainId: ChainId, amount: bigint, recipient?: Address): BundlerCall[];
+    function wrapNative(chainId: ChainId, amount: bigint, recipient: Address, skipRevert?: boolean): BundlerCall[];
     /**
-     * Encodes a call to the Adapter to unwrap native tokens (WETH to ETH on ethereum, WMATIC to MATIC on polygon, etc).
+     * Encodes a call to the GeneralAdapter1 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.
+     * @param recipient The address to send tokens to.
+     * @param skipRevert Whether to allow the transfer to revert without making the whole bundler revert. Defaults to false.
      */
-    function unwrapNative(chainId: ChainId, amount: bigint, recipient?: Address): BundlerCall[];
+    function unwrapNative(chainId: ChainId, amount: bigint, recipient: Address, skipRevert?: boolean): BundlerCall[];
     /**
-     * Encodes a call to the Adapter to stake native tokens using Lido (ETH to stETH on ethereum).
+     * Encodes a call to the GeneralAdapter1 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 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.
+     * @param recipient The address to send stETH to.
+     * @param skipRevert Whether to allow the transfer to revert without making the whole bundler revert. Defaults to false.
      */
-    function stakeEth(chainId: ChainId, amount: bigint, maxSharePrice: bigint, referral: Address, recipient?: Address): BundlerCall[];
+    function stakeEth(chainId: ChainId, amount: bigint, maxSharePrice: bigint, referral: Address, recipient: Address, skipRevert?: boolean): BundlerCall[];
     /**
-     * Encodes a call to the Adapter to wrap stETH (stETH to wstETH on ethereum).
+     * Encodes a call to the GeneralAdapter1 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.
+     * @param recipient The address to send wstETH to.
+     * @param skipRevert Whether to allow the transfer to revert without making the whole bundler revert. Defaults to false.
      */
-    function wrapStEth(chainId: ChainId, amount: bigint, recipient?: Address): BundlerCall[];
+    function wrapStEth(chainId: ChainId, amount: bigint, recipient: Address, skipRevert?: boolean): BundlerCall[];
     /**
-     * Encodes a call to the Adapter to unwrap wstETH (wstETH to stETH on ethereum).
+     * Encodes a call to the GeneralAdapter1 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.
+     * @param recipient The address to send stETH to.
+     * @param skipRevert Whether to allow the transfer to revert without making the whole bundler revert. Defaults to false.
      */
-    function unwrapStEth(chainId: ChainId, amount: bigint, recipient?: Address): BundlerCall[];
+    function unwrapStEth(chainId: ChainId, amount: bigint, recipient: Address, skipRevert?: boolean): BundlerCall[];
     /**
-     * Encodes a call to the Adapter to repay a debt on AaveV2.
+     * Encodes a call to the AaveV2MigrationAdapter 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.
+     * @param skipRevert Whether to allow the transfer to revert without making the whole bundler revert. Defaults to false.
      */
-    function aaveV2Repay(chainId: ChainId, asset: Address, amount: bigint, onBehalf: Address, rateMode?: bigint): BundlerCall[];
+    function aaveV2Repay(chainId: ChainId, asset: Address, amount: bigint, onBehalf: Address, rateMode?: bigint, skipRevert?: boolean): BundlerCall[];
     /**
-     * Encodes a call to the Adapter to withdrawn from AaveV2.
+     * Encodes a call to the AaveV2MigrationAdapter to withdraw 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.
+     * @param recipient The recipient of ERC20 tokens.
+     * @param skipRevert Whether to allow the transfer to revert without making the whole bundler revert. Defaults to false.
      */
-    function aaveV2Withdraw(chainId: ChainId, asset: Address, amount: bigint, recipient?: Address): BundlerCall[];
+    function aaveV2Withdraw(chainId: ChainId, asset: Address, amount: bigint, recipient: Address, skipRevert?: boolean): BundlerCall[];
     /**
-     * Encodes a call to the Adapter to repay a debt on AaveV3.
+     * Encodes a call to the AaveV3CoreMigrationAdapter 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.
+     * @param skipRevert Whether to allow the transfer to revert without making the whole bundler revert. Defaults to false.
      */
-    function aaveV3Repay(chainId: ChainId, asset: Address, amount: bigint, onBehalf: Address, rateMode?: bigint): BundlerCall[];
+    function aaveV3Repay(chainId: ChainId, asset: Address, amount: bigint, onBehalf: Address, rateMode?: bigint, skipRevert?: boolean): BundlerCall[];
     /**
-     * Encodes a call to the Adapter to withdrawn from AaveV3.
+     * Encodes a call to the AaveV3CoreMigrationAdapter 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.
+     * @param recipient The recipient of ERC20 tokens.
+     * @param skipRevert Whether to allow the transfer to revert without making the whole bundler revert. Defaults to false.
      */
-    function aaveV3Withdraw(chainId: ChainId, asset: Address, amount: bigint, recipient?: Address): BundlerCall[];
+    function aaveV3Withdraw(chainId: ChainId, asset: Address, amount: bigint, recipient: Address, skipRevert?: boolean): BundlerCall[];
     /**
-     * Encodes a call to the Adapter to repay a debt on Morpho's AaveV3Optimizer.
+     * Encodes a call to the AaveV3OptimizerMigrationAdapter 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 onBehalf The address on behalf of which to repay.
+     * @param skipRevert Whether to allow the transfer to revert without making the whole bundler revert. Defaults to false.
      */
-    function aaveV3OptimizerRepay(chainId: ChainId, underlying: Address, amount: bigint, onBehalf: Address): BundlerCall[];
+    function aaveV3OptimizerRepay(chainId: ChainId, underlying: Address, amount: bigint, onBehalf: Address, skipRevert?: boolean): BundlerCall[];
     /**
-     * Encodes a call to the Adapter to withdraw from Morpho's AaveV3Optimizer.
+     * Encodes a call to the AaveV3OptimizerMigrationAdapter 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.
+     * @param recipient The recipient of ERC20 tokens.
+     * @param skipRevert Whether to allow the transfer to revert without making the whole bundler revert. Defaults to false.
      */
-    function aaveV3OptimizerWithdraw(chainId: ChainId, underlying: Address, amount: bigint, maxIterations: bigint, recipient?: Address): BundlerCall[];
+    function aaveV3OptimizerWithdraw(chainId: ChainId, underlying: Address, amount: bigint, maxIterations: bigint, recipient: Address, skipRevert?: boolean): BundlerCall[];
     /**
-     * Encodes a call to the Adapter to withdraw collateral from Morpho's AaveV3Optimizer.
+     * Encodes a call to the AaveV3OptimizerMigrationAdapter 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.
+     * @param recipient The recipient of ERC20 tokens.
+     * @param skipRevert Whether to allow the transfer to revert without making the whole bundler revert. Defaults to false.
      */
-    function aaveV3OptimizerWithdrawCollateral(chainId: ChainId, underlying: Address, amount: bigint, recipient?: Address): BundlerCall[];
+    function aaveV3OptimizerWithdrawCollateral(chainId: ChainId, underlying: Address, amount: bigint, recipient: Address, skipRevert?: boolean): BundlerCall[];
     /**
-     * Encodes a call to the Adapter to approve the Bundler as the sender's manager on Morpho's AaveV3Optimizer.
+     * Encodes a call to the AaveV3 optimizer to approve the chain's AaveV3OptimizerMigrationAdapter.
+     * 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.
+     * @param skipRevert Whether to allow the signature to revert without making the whole bundle revert. Defaults to true.
      */
-    function aaveV3OptimizerApproveManagerWithSig(chainId: ChainId, aaveV3Optimizer: Address, owner: Address, isApproved: boolean, nonce: bigint, deadline: bigint, signature: Hex, manager?: Address, skipRevert?: boolean): BundlerCall[];
+    function aaveV3OptimizerApproveManagerWithSig(chainId: ChainId, aaveV3Optimizer: Address, owner: Address, isApproved: boolean, nonce: bigint, deadline: bigint, signature: Hex, skipRevert?: boolean): BundlerCall[];
     /**
-     * Encodes a call to the Adapter to repay a debt on CompoundV2.
+     * Encodes a call to the CompoundV2MigrationAdapter 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.
+     * @param onBehalf The account on behalf of which to repay.
+     * @param skipRevert Whether to allow the transfer to revert without making the whole bundler revert. Defaults to false.
      */
-    function compoundV2Repay(chainId: ChainId, cToken: Address, amount: bigint, isEth: boolean, onBehalf: Address): BundlerCall[];
+    function compoundV2Repay(chainId: ChainId, cToken: Address, amount: bigint, isEth: boolean, onBehalf: Address, skipRevert?: boolean): BundlerCall[];
     /**
-     * Encodes a call to the Adapter to withdraw collateral from CompoundV2.
+     * Encodes a call to the CompoundV2MigrationAdapter 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.
+     * @param recipient The recipient of ERC20 tokens.
+     * @param skipRevert Whether to allow the transfer to revert without making the whole bundler revert. Defaults to false.
      */
-    function compoundV2Redeem(chainId: ChainId, cToken: Address, amount: bigint, isEth: boolean, recipient?: Address): BundlerCall[];
+    function compoundV2Redeem(chainId: ChainId, cToken: Address, amount: bigint, isEth: boolean, recipient: Address, skipRevert?: boolean): BundlerCall[];
     /**
-     * Encodes a call to the Adapter to repay a debt on CompoundV3.
+     * Encodes a call to the CompoundV3MigrationAdapter 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.
+     * @param skipRevert Whether to allow the transfer to revert without making the whole bundler revert. Defaults to false.
      */
-    function compoundV3Repay(chainId: ChainId, instance: Address, amount: bigint, onBehalf: Address): BundlerCall[];
+    function compoundV3Repay(chainId: ChainId, instance: Address, amount: bigint, onBehalf: Address, skipRevert?: boolean): BundlerCall[];
     /**
-     * Encodes a call to the Adapter to withdraw collateral from CompoundV3.
+     * Encodes a call to the CompoundV3MigrationAdapter 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.
+     * @param recipient The recipient of ERC20 tokens.
+     * @param skipRevert Whether to allow the transfer to revert without making the whole bundler revert. Defaults to false.
      */
-    function compoundV3WithdrawFrom(chainId: ChainId, instance: Address, asset: Address, amount: bigint, recipient?: Address): BundlerCall[];
+    function compoundV3WithdrawFrom(chainId: ChainId, instance: Address, asset: Address, amount: bigint, recipient: Address, skipRevert?: boolean): BundlerCall[];
     /**
-     * Encodes a call to the Adapter to allow the Bundler to act on the sender's position on CompoundV3.
+     * Encodes a call to the CompoundV3 instance to allow the chain's CompoundV3MigrationAdapter.
+     * 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.
@@ -383,8 +417,7 @@ export declare namespace BundlerAction {
      * @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.
+     * @param skipRevert Whether to allow the signature to revert without making the whole bundle revert. Defaults to true.
      */
-    function compoundV3AllowBySig(chainId: ChainId, instance: Address, owner: Address, isAllowed: boolean, nonce: bigint, expiry: bigint, signature: Hex, manager?: Address, skipRevert?: boolean): BundlerCall[];
+    function compoundV3AllowBySig(chainId: ChainId, instance: Address, owner: Address, isAllowed: boolean, nonce: bigint, expiry: bigint, signature: Hex, skipRevert?: boolean): BundlerCall[];
 }