@morpho-org/bundler-sdk-viem 4.2.0 → 4.3.0

package/lib/cjs/package.json

@@ -0,0 +1 @@
+{"type":"commonjs"}

package/lib/esm/ActionBundle.d.ts

@@ -0,0 +1,37 @@
+import type { SimulationResult } from "@morpho-org/simulation-sdk";
+import type { Account, Address, Chain, Client, Hex, Transport } from "viem";
+import type { Action, SignatureRequirement, TransactionRequirement } from "./types/index.js";
+export declare class ActionBundleRequirements<TR extends {
+    tx: {
+        to: Address;
+        data: Hex;
+    };
+} = TransactionRequirement, SR extends SignatureRequirement = SignatureRequirement> {
+    readonly txs: TR[];
+    readonly signatures: SR[];
+    constructor(txs?: TR[], signatures?: SR[]);
+    sign(client: Client<Transport, Chain | undefined, Account>): Promise<Hex[]>;
+    sign(client: Client, account: Account): Promise<Hex[]>;
+}
+export declare class ActionBundle<TR extends {
+    tx: {
+        to: Address;
+        data: Hex;
+    };
+} = TransactionRequirement, SR extends SignatureRequirement = SignatureRequirement> {
+    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;
+        data: `0x${string}`;
+    };
+    txs(): {
+        to: Address;
+        data: Hex;
+    }[];
+}

package/lib/esm/ActionBundle.js

@@ -0,0 +1,35 @@
+import { BundlerAction } from "./BundlerAction.js";
+export class ActionBundleRequirements {
+    txs;
+    signatures;
+    constructor(txs = [], signatures = []) {
+        this.txs = txs;
+        this.signatures = signatures;
+    }
+    sign(client, account = client.account) {
+        return Promise.all(this.signatures.map((requirement) => requirement.sign(client, account)));
+    }
+}
+export class ActionBundle {
+    actions;
+    requirements;
+    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.chainId, this.actions);
+    }
+    txs() {
+        return this.requirements.txs.map(({ tx }) => tx).concat([this.tx()]);
+    }
+}

package/lib/esm/BundlerAction.d.ts

@@ -0,0 +1,470 @@
+import { ChainId, type InputMarketParams } from "@morpho-org/blue-sdk";
+import type { ParaswapOffsets } from "@morpho-org/simulation-sdk";
+import { type Address, type Hex } from "viem";
+import type { Action, Authorization, InputReallocation, Permit2PermitSingle } from "./types/index.js";
+export interface BundlerCall {
+    to: Address;
+    data: Hex;
+    value: bigint;
+    skipRevert: boolean;
+    callbackHash: Hex;
+}
+/**
+ * Namespace to easily encode calls to the Bundler contract, using viem.
+ */
+export declare namespace BundlerAction {
+    function encodeBundle(chainId: ChainId, actions: Action[]): {
+        to: `0x${string}`;
+        value: bigint;
+        data: `0x${string}`;
+    };
+    function encode(chainId: ChainId, { type, args }: Action): BundlerCall[];
+    /**
+     * 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, skipRevert?: boolean): BundlerCall[];
+    /**
+     * 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(asset: Address, recipient: Address, amount: bigint, adapter: Address, skipRevert?: boolean): BundlerCall[];
+    /**
+     * 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.
+     * @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, skipRevert?: boolean): BundlerCall[];
+    /**
+     * 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 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, skipRevert?: boolean): BundlerCall[];
+    /**
+     * 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 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, skipRevert?: boolean): BundlerCall[];
+    /**
+     * 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 bundle revert. Defaults to true.
+     */
+    function approve2(chainId: ChainId, owner: Address, permitSingle: Permit2PermitSingle, signature: Hex, skipRevert?: boolean): BundlerCall[];
+    /**
+     * 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.
+     * @param skipRevert Whether to allow the transfer to revert without making the whole bundler revert. Defaults to false.
+     */
+    function transferFrom2(chainId: ChainId, asset: Address, amount: bigint, recipient: Address, skipRevert?: boolean): BundlerCall[];
+    /**
+     * Encodes a call to the GeneralAdapter1 to wrap legacy MORPHO tokens.
+     * @param chainId The chain id for which to encode the call.
+     * @param recipient The recipient of MORPHO tokens.
+     * @param amount The amount of tokens to wrap.
+     * @param skipRevert Whether to allow the wrap to revert without making the whole bundler revert. Defaults to false.
+     */
+    function morphoWrapperDepositFor(chainId: ChainId, recipient: Address, amount: bigint, skipRevert?: boolean): BundlerCall[];
+    /**
+     * 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, skipRevert?: boolean): BundlerCall[];
+    /**
+     * 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, skipRevert?: boolean): BundlerCall[];
+    /**
+     * 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, skipRevert?: boolean): BundlerCall[];
+    /**
+     * 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, skipRevert?: boolean): BundlerCall[];
+    /**
+     * 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, skipRevert?: boolean): BundlerCall[];
+    /**
+     * 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, skipRevert?: boolean): BundlerCall[];
+    /**
+     * 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 bundle revert. Defaults to true.
+     */
+    function morphoSetAuthorizationWithSig(chainId: ChainId, authorization: Authorization, signature: Hex, skipRevert?: boolean): BundlerCall[];
+    /**
+     * 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.
+     * @param shares The amount of supply shares to mint.
+     * @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[], skipRevert?: boolean): BundlerCall[];
+    /**
+     * 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[], skipRevert?: boolean): BundlerCall[];
+    /**
+     * 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, skipRevert?: boolean): BundlerCall[];
+    /**
+     * 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.
+     * @param shares The amount of borrow shares to redeem.
+     * @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[], skipRevert?: boolean): BundlerCall[];
+    /**
+     * 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, skipRevert?: boolean): BundlerCall[];
+    /**
+     * 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, skipRevert?: boolean): BundlerCall[];
+    /**
+     * Encodes a call to the GeneralAdapter1 to flash loan from Morpho Blue.
+     * @param chainId The chain id for which to encode the call.
+     * @param token The address of the ERC20 token to flash loan.
+     * @param assets The amount of tokens to flash loan.
+     * @param callbackCalls The array of calls to execute inside Morpho Blue's `onMorphoFlashLoan` callback.
+     * @param skipRevert Whether to allow the transfer to revert without making the whole bundler revert. Defaults to false.
+     */
+    function morphoFlashLoan(chainId: ChainId, token: Address, assets: bigint, callbackCalls: BundlerCall[], skipRevert?: boolean): BundlerCall[];
+    /**
+     * Encodes a call to trigger a public reallocation on the PublicAllocator.
+     * @param chainId The chain id for which to encode the call.
+     * @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, skipRevert?: boolean): BundlerCall[];
+    /**
+     * Encodes a call to the ParaswapAdapter to buy an exact amount of tokens via Paraswap.
+     * @param chainId The chain id for which to encode the call.
+     * @param augustus The address of the Augustus router to use.
+     * @param callData The encoded call data to execute.
+     * @param srcToken The address of the source token.
+     * @param dstToken The address of the destination token.
+     * @param offsets The offsets in callData of the exact buy amount (`exactAmount`), maximum sell amount (`limitAmount`) and quoted sell amount (`quotedAmount`).
+     * @param receiver The address to send the tokens to.
+     * @param skipRevert Whether to allow the swap to revert without making the whole bundle revert. Defaults to false.
+     */
+    function paraswapBuy(chainId: ChainId, augustus: Address, callData: Hex, srcToken: Address, dstToken: Address, offsets: ParaswapOffsets, receiver: Address, skipRevert?: boolean): BundlerCall[];
+    /**
+     * Encodes a call to the ParaswapAdapter to sell an exact amount of tokens via Paraswap.
+     * @param chainId The chain id for which to encode the call.
+     * @param augustus The address of the Augustus router to use.
+     * @param callData The encoded call data to execute.
+     * @param srcToken The address of the source token.
+     * @param dstToken The address of the destination token.
+     * @param sellEntireBalance Whether to sell the entire balance of the source token.
+     * @param offsets The offsets in callData of the exact sell amount (`exactAmount`), minimum buy amount (`limitAmount`) and quoted buy amount (`quotedAmount`).
+     * @param receiver The address to send the tokens to.
+     * @param skipRevert Whether to allow the swap to revert without making the whole bundle revert. Defaults to false.
+     */
+    function paraswapSell(chainId: ChainId, augustus: Address, callData: Hex, srcToken: Address, dstToken: Address, sellEntireBalance: boolean, offsets: ParaswapOffsets, receiver: Address, skipRevert?: boolean): BundlerCall[];
+    /**
+     * Encodes a call to the ParaswapAdapter to buy the exact debt of a position via Paraswap.
+     * @param chainId The chain id for which to encode the call.
+     * @param augustus The address of the Augustus router to use.
+     * @param callData The encoded call data to execute.
+     * @param srcToken The address of the source token.
+     * @param marketParams The market params of the market with the debt assets to buy.
+     * @param offsets The offsets in callData of the exact buy amount (`exactAmount`), maximum sell amount (`limitAmount`) and quoted sell amount (`quotedAmount`).
+     * @param onBehalf The address to buy the debt on behalf of.
+     * @param receiver The address to send the tokens to.
+     * @param skipRevert Whether to allow the swap to revert without making the whole bundle revert. Defaults to false.
+     */
+    function paraswapBuyMorphoDebt(chainId: ChainId, augustus: Address, callData: Hex, srcToken: Address, marketParams: InputMarketParams, offsets: ParaswapOffsets, onBehalf: Address, receiver: Address, skipRevert?: boolean): BundlerCall[];
+    /**
+     * Encodes a call to the Universal Rewards Distributor to claim rewards.
+     * @param chainId The chain id for which to encode the call.
+     * @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 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 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.
+     * @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, skipRevert?: boolean): BundlerCall[];
+    /**
+     * 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.
+     * @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, skipRevert?: boolean): BundlerCall[];
+    /**
+     * 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.
+     * @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, skipRevert?: boolean): BundlerCall[];
+    /**
+     * 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.
+     * @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, skipRevert?: boolean): BundlerCall[];
+    /**
+     * 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.
+     * @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, skipRevert?: boolean): BundlerCall[];
+    /**
+     * 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, skipRevert?: boolean): BundlerCall[];
+    /**
+     * 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.
+     * @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, skipRevert?: boolean): BundlerCall[];
+    /**
+     * 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, skipRevert?: boolean): BundlerCall[];
+    /**
+     * 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.
+     * @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, skipRevert?: boolean): BundlerCall[];
+    /**
+     * 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, skipRevert?: boolean): BundlerCall[];
+    /**
+     * 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.
+     * @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, skipRevert?: boolean): BundlerCall[];
+    /**
+     * 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.
+     * @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, skipRevert?: boolean): BundlerCall[];
+    /**
+     * 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 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, skipRevert?: boolean): BundlerCall[];
+    /**
+     * 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 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, skipRevert?: boolean): BundlerCall[];
+    /**
+     * 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.
+     * @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, skipRevert?: boolean): BundlerCall[];
+    /**
+     * 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, skipRevert?: boolean): BundlerCall[];
+    /**
+     * 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.
+     * @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, skipRevert?: boolean): BundlerCall[];
+    /**
+     * 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.
+     * @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 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, skipRevert?: boolean): BundlerCall[];
+}