@morpho-org/bundler-sdk-viem 3.0.0-next.10 → 3.0.0-next.12

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

@@ -11,16 +11,23 @@ export class ActionBundleRequirements {
     }
 }
 export class ActionBundle {
-    steps;
     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.encodeBundle(this.chainId, this.actions);
     }
     txs() {
         return this.requirements.txs.map(({ tx }) => tx).concat([this.tx()]);

package/lib/BundlerAction.d.ts

@@ -24,24 +24,28 @@ export declare namespace BundlerAction {
      * @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.
      * @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. Defaults to the chain's bundler3 general adapter.
+     * @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(chainId: ChainId, 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.
      * @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 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.
      * @param chainId The chain id for which to encode the call.
@@ -51,7 +55,7 @@ export declare namespace BundlerAction {
      * @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[];
     /**
@@ -63,7 +67,7 @@ export declare namespace BundlerAction {
      * @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[];
     /**
@@ -72,7 +76,7 @@ export declare namespace BundlerAction {
      * @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[];
     /**
@@ -82,24 +86,27 @@ export declare namespace BundlerAction {
      * @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 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, owner: Address, amount: bigint, recipient?: Address, skipRevert?: boolean): BundlerCall[];
     /**
      * 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.
+     * @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.
      * @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.
      * @param chainId The chain id for which to encode the call.
@@ -107,8 +114,9 @@ export declare namespace BundlerAction {
      * @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.
      * @param chainId The chain id for which to encode the call.
@@ -116,8 +124,9 @@ export declare namespace BundlerAction {
      * @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.
      * @param chainId The chain id for which to encode the call.
@@ -126,8 +135,9 @@ export declare namespace BundlerAction {
      * @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.
      * @param chainId The chain id for which to encode the call.
@@ -136,14 +146,15 @@ export declare namespace BundlerAction {
      * @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.
      * @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[];
     /**
@@ -155,8 +166,9 @@ 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.
      * @param chainId The chain id for which to encode the call.
@@ -164,8 +176,9 @@ export declare namespace BundlerAction {
      * @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.
      * @param chainId The chain id for which to encode the call.
@@ -174,8 +187,9 @@ export declare namespace BundlerAction {
      * @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.
      * @param chainId The chain id for which to encode the call.
@@ -185,8 +199,9 @@ 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.
      * @param chainId The chain id for which to encode the call.
@@ -195,24 +210,27 @@ export declare namespace BundlerAction {
      * @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.
      * @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.
      * @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.
      * @param chainId The chain id for which to encode the call.
@@ -220,8 +238,9 @@ export declare namespace BundlerAction {
      * @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.
      * @param chainId The chain id for which to encode the call.
@@ -230,7 +249,7 @@ export declare namespace BundlerAction {
      * @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[];
     /**
@@ -238,15 +257,17 @@ export declare namespace BundlerAction {
      * @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 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).
      * @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 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).
      * @param chainId The chain id for which to encode the call.
@@ -254,22 +275,25 @@ export declare namespace BundlerAction {
      * @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 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).
      * @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 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).
      * @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 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.
      * @param chainId The chain id for which to encode the call.
@@ -277,16 +301,18 @@ export declare namespace BundlerAction {
      * @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.
      * @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 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.
      * @param chainId The chain id for which to encode the call.
@@ -294,24 +320,27 @@ export declare namespace BundlerAction {
      * @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.
      * @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 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.
      * @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.
      * @param chainId The chain id for which to encode the call.
@@ -319,16 +348,18 @@ export declare namespace BundlerAction {
      * @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 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.
      * @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 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.
      * @param chainId The chain id for which to encode the call.
@@ -338,7 +369,7 @@ export declare namespace BundlerAction {
      * @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[];
     /**
@@ -347,24 +378,27 @@ export declare namespace BundlerAction {
      * @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 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.
      * @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 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.
      * @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.
      * @param chainId The chain id for which to encode the call.
@@ -372,8 +406,9 @@ export declare namespace BundlerAction {
      * @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 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.
      * @param chainId The chain id for which to encode the call.
@@ -384,7 +419,7 @@ export declare namespace BundlerAction {
      * @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[];
 }