@morpho-org/bundler-sdk-viem 1.12.4

package/lib/index.js

@@ -0,0 +1,4 @@
+export * from "./actions.js";
+export * from "./operations.js";
+export * from "./errors.js";
+export * from "./types/index.js";

package/lib/operations.d.ts

@@ -0,0 +1,62 @@
+import { type Address, type MarketId } from "@morpho-org/blue-sdk";
+import { type MaybeDraft, type Operation, type Operations, type PublicAllocatorOptions, type SimulationResult, type SimulationState } from "@morpho-org/simulation-sdk";
+import type { BundlerOperation, CallbackBundlerOperation, InputBundlerOperation } from "./types/index.js";
+export interface BundlingOptions {
+    withSimplePermit?: Set<Address>;
+    publicAllocatorOptions?: PublicAllocatorOptions & {
+        supplyTargetUtilization?: Record<MarketId, bigint | undefined>;
+    };
+    getRequirementOperations?: (requiredTokenAmounts: {
+        token: Address;
+        required: bigint;
+    }[]) => BundlerOperation[];
+}
+export declare const populateInputTransfer: ({ address, args: { amount, from } }: Operations["Erc20_Transfer"], data: MaybeDraft<SimulationState>, { hasSimplePermit }?: {
+    hasSimplePermit?: boolean;
+}) => Exclude<BundlerOperation, CallbackBundlerOperation>[];
+/**
+ * Simulates the input operation on the given simulation data with args tweaked so the bundler operates on behalf of the sender.
+ * Then, populates a bundle of operations made of:
+ * - required approvals to the bundler
+ * - required input transfers to the bundler
+ * - required token wrapping
+ * - the given operation
+ * @param inputOperation The input operation to populate a bundle for.
+ * @param data The simulation data to determine the required steps of the bundle to populate. If the provided simulation data is the result of a simulation
+ * of an already populated bundle, the `Transfer` and `Wrap` operation are only populated if required.
+ * @param wrapSlippage The slippage simulated during wraps. Should never be 0.
+ * @return The bundle of operations to optimize and skim before being encoded.
+ */
+export declare const populateSubBundle: (inputOperation: InputBundlerOperation, data: MaybeDraft<SimulationState>, options?: BundlingOptions) => BundlerOperation[];
+/**
+ * Merges unnecessary duplicate `Erc20_Approve`, `Erc20_Transfer` and `Erc20_Wrap`.
+ * Also redirects `Blue_Borrow|Withdraw|WithdrawCollateral` & `MetaMorpho_Withdraw` operations from the bundler to the receiver,
+ * as long as the tokens received (possibly ERC4626 shares) are not used afterwards in the bundle.
+ * For all the other remaining tokens, appends `Erc20_Transfer` operations to the bundle, from the bundler to the receiver.
+ * @param operations The bundle to optimize.
+ * @param startData The start data from which to simulate th bundle.
+ * @param receiver The receiver of skimmed tokens.
+ * @param unwrapTokens The set of tokens to unwrap before transferring to the receiver.
+ * @param unwrapSlippage The slippage simulated during unwraps. Should never be 0.
+ * @return The optimized bundle.
+ */
+export declare const finalizeBundle: (operations: BundlerOperation[], startData: SimulationState, receiver: Address, unwrapTokens?: Set<`0x${string}`>, unwrapSlippage?: bigint) => BundlerOperation[];
+export declare const populateBundle: (inputOperations: InputBundlerOperation[], data: MaybeDraft<SimulationState>, options?: BundlingOptions) => {
+    operations: BundlerOperation[];
+    steps: SimulationResult;
+};
+export declare const getSimulatedBundlerOperation: (operation: BundlerOperation, { slippage }?: {
+    slippage?: bigint;
+}) => Operation;
+export declare const handleBundlerOperation: (options?: {
+    slippage?: bigint;
+}) => (operation: BundlerOperation, startData: MaybeDraft<SimulationState>, index?: number) => MaybeDraft<SimulationState>;
+export declare const handleBundlerOperations: (operations: BundlerOperation[], startData: MaybeDraft<SimulationState>, options?: {
+    slippage?: bigint;
+}) => SimulationResult;
+export declare const simulateBundlerOperation: (options?: {
+    slippage?: bigint;
+}) => (operation: BundlerOperation, startData: MaybeDraft<SimulationState>, index?: number) => MaybeDraft<SimulationState>;
+export declare const simulateBundlerOperations: (operations: BundlerOperation[], startData: MaybeDraft<SimulationState>, options?: {
+    slippage?: bigint;
+}) => SimulationResult;

package/lib/operations.js

@@ -0,0 +1,595 @@
+import { DEFAULT_SLIPPAGE_TOLERANCE, DEFAULT_SUPPLY_TARGET_UTILIZATION, MarketUtils, MathLib, NATIVE_ADDRESS, erc20WrapperTokens, getChainAddresses, getUnwrappedToken, permissionedBackedTokens, permissionedWrapperTokens, } from "@morpho-org/blue-sdk";
+import { entries, getLast, getValue, keys } from "@morpho-org/morpho-ts";
+import { handleOperation, handleOperations, produceImmutable, simulateOperation, } from "@morpho-org/simulation-sdk";
+import { maxUint256 } from "viem";
+import { BundlerErrors } from "./errors.js";
+export const populateInputTransfer = ({ address, args: { amount, from } }, data, { hasSimplePermit = false } = {}) => {
+    const { bundler, permit2 } = getChainAddresses(data.chainId);
+    // If native token, it is expected to be sent along as call value.
+    if (address === NATIVE_ADDRESS)
+        return [
+            {
+                type: "Erc20_Transfer",
+                sender: from,
+                address,
+                args: {
+                    amount,
+                    from,
+                    to: bundler,
+                },
+            },
+        ];
+    const { erc20Allowances, permit2Allowances, erc2612Nonce } = data.getHolding(from, address);
+    // ERC20 allowance to the bundler is enough, consume it.
+    if (erc20Allowances.bundler >= amount)
+        return [
+            {
+                type: "Erc20_Transfer",
+                sender: bundler,
+                address,
+                args: {
+                    amount,
+                    from,
+                    to: bundler,
+                },
+            },
+        ];
+    const operations = [];
+    // Try using simple permit.
+    const useSimplePermit = erc2612Nonce != null &&
+        (data.tryGetVault(address) != null || // MetaMorpho vaults implement EIP-2612.
+            hasSimplePermit);
+    const isPermissioned = permissionedWrapperTokens[data.chainId].has(address) ||
+        permissionedBackedTokens[data.chainId].has(address);
+    if (useSimplePermit)
+        operations.push({
+            type: "Erc20_Permit",
+            sender: from,
+            address,
+            args: {
+                amount,
+                spender: bundler,
+                nonce: erc2612Nonce,
+            },
+        });
+    // Token is permissioned and Permit2 may not be authorized so Permit2 cannot be used.
+    else if (isPermissioned)
+        operations.push({
+            type: "Erc20_Approve",
+            sender: from,
+            address,
+            args: {
+                amount,
+                spender: bundler,
+            },
+        });
+    if (useSimplePermit || isPermissioned)
+        operations.push({
+            type: "Erc20_Transfer",
+            sender: bundler,
+            address,
+            args: {
+                amount,
+                from,
+                to: bundler,
+            },
+        });
+    // Simple permit is not supported and token is not permissioned: fallback to Permit2.
+    else {
+        if (erc20Allowances.permit2 < amount)
+            operations.push({
+                type: "Erc20_Approve",
+                sender: from,
+                address,
+                args: {
+                    amount: MathLib.MAX_UINT_160, // Always approve infinite.
+                    spender: permit2,
+                },
+            });
+        if (permit2Allowances.bundler.amount < amount ||
+            permit2Allowances.bundler.expiration < data.block.timestamp)
+            operations.push({
+                type: "Erc20_Permit2",
+                sender: from,
+                address,
+                args: {
+                    amount,
+                    spender: bundler,
+                    expiration: MathLib.MAX_UINT_48, // Always approve indefinitely.
+                    nonce: permit2Allowances.bundler.nonce,
+                },
+            });
+        operations.push({
+            type: "Erc20_Transfer2",
+            sender: bundler,
+            address,
+            args: {
+                amount,
+                from,
+                to: bundler,
+            },
+        });
+    }
+    return operations;
+};
+/**
+ * Simulates the input operation on the given simulation data with args tweaked so the bundler operates on behalf of the sender.
+ * Then, populates a bundle of operations made of:
+ * - required approvals to the bundler
+ * - required input transfers to the bundler
+ * - required token wrapping
+ * - the given operation
+ * @param inputOperation The input operation to populate a bundle for.
+ * @param data The simulation data to determine the required steps of the bundle to populate. If the provided simulation data is the result of a simulation
+ * of an already populated bundle, the `Transfer` and `Wrap` operation are only populated if required.
+ * @param wrapSlippage The slippage simulated during wraps. Should never be 0.
+ * @return The bundle of operations to optimize and skim before being encoded.
+ */
+export const populateSubBundle = (inputOperation, data, options = {}) => {
+    const { sender } = inputOperation;
+    const { morpho, bundler } = getChainAddresses(data.chainId);
+    const { withSimplePermit = new Set(), publicAllocatorOptions, getRequirementOperations, } = options;
+    const operations = [];
+    const wrappedToken = inputOperation.type === "Erc20_Wrap"
+        ? data.getWrappedToken(inputOperation.address)
+        : undefined;
+    const isErc20Wrapper = !!wrappedToken &&
+        erc20WrapperTokens[data.chainId].has(wrappedToken.address);
+    // Transform input operation to act on behalf of the sender, via the bundler.
+    const mainOperation = produceImmutable(inputOperation, (draft) => {
+        draft.sender = bundler;
+        // Redirect MetaMorpho operation owner.
+        switch (draft.type) {
+            case "Erc20_Wrap": {
+                // ERC20Wrapper are skipped because tokens are sent to the caller, not the bundler.
+                if (isErc20Wrapper) {
+                    draft.args.owner = sender;
+                    break;
+                }
+            }
+            case "MetaMorpho_Deposit":
+            case "MetaMorpho_Withdraw":
+                // Only if sender is owner otherwise the owner would be lost.
+                if (draft.args.owner === sender)
+                    draft.args.owner = bundler;
+        }
+        // Redirect operation targets.
+        switch (draft.type) {
+            case "Blue_Borrow":
+            case "Blue_Withdraw":
+            case "Blue_WithdrawCollateral":
+                draft.args.onBehalf = sender;
+            case "MetaMorpho_Withdraw":
+                // Only if sender is receiver otherwise the receiver would be lost.
+                if (draft.args.receiver === sender)
+                    draft.args.receiver = bundler;
+        }
+    });
+    const needsBundlerAuthorization = mainOperation.type === "Blue_Borrow" ||
+        mainOperation.type === "Blue_Withdraw" ||
+        mainOperation.type === "Blue_WithdrawCollateral";
+    if (needsBundlerAuthorization && !data.getUser(sender).isBundlerAuthorized)
+        operations.push({
+            type: "Blue_SetAuthorization",
+            sender: bundler,
+            address: morpho,
+            args: {
+                owner: sender,
+                isBundlerAuthorized: true,
+            },
+        });
+    // Reallocate liquidity if necessary.
+    if (mainOperation.type === "Blue_Borrow" ||
+        mainOperation.type === "Blue_Withdraw") {
+        const market = data
+            .getMarket(mainOperation.args.id)
+            .accrueInterest(data.block.timestamp);
+        const borrowedAssets = mainOperation.type === "Blue_Borrow"
+            ? (mainOperation.args.assets ??
+                market.toBorrowAssets(mainOperation.args.shares))
+            : 0n;
+        const withdrawnAssets = mainOperation.type === "Blue_Withdraw"
+            ? (mainOperation.args.assets ??
+                market.toSupplyAssets(mainOperation.args.shares))
+            : 0n;
+        const newTotalSupplyAssets = market.totalSupplyAssets - withdrawnAssets;
+        const newTotalBorrowAssets = market.totalBorrowAssets + borrowedAssets;
+        const reallocations = {};
+        const supplyTargetUtilization = publicAllocatorOptions?.supplyTargetUtilization?.[market.config.id] ??
+            DEFAULT_SUPPLY_TARGET_UTILIZATION;
+        if (MarketUtils.getUtilization({
+            totalSupplyAssets: newTotalSupplyAssets,
+            totalBorrowAssets: newTotalBorrowAssets,
+        }) > supplyTargetUtilization) {
+            // Liquidity is insufficient: trigger a public reallocation and try to have a resulting utilization as low as possible, above the target.
+            // Solve: newTotalBorrowAssets / (newTotalSupplyAssets + reallocatedAssets) = supplyTargetUtilization
+            // Worst case is: there is not enough withdrawals available to fill reallocatedAssets, so utilization is above supplyTargetUtilization.
+            let requiredAssets = supplyTargetUtilization === 0n
+                ? MathLib.MAX_UINT_160
+                : MathLib.wDivDown(newTotalBorrowAssets, supplyTargetUtilization) -
+                    newTotalSupplyAssets;
+            const { withdrawals } = data.getMarketPublicReallocations(market.id, publicAllocatorOptions);
+            for (const { vault, ...withdrawal } of withdrawals) {
+                const vaultReallocations = (reallocations[vault] ??= []);
+                if (withdrawal.assets > requiredAssets) {
+                    vaultReallocations.push({
+                        ...withdrawal,
+                        assets: requiredAssets,
+                    });
+                    break;
+                }
+                requiredAssets -= withdrawal.assets;
+                vaultReallocations.push(withdrawal);
+            }
+            const fees = keys(reallocations).reduce((total, vault) => total + data.getVault(vault).publicAllocatorConfig.fee, 0n);
+            // Native input transfer of all fees.
+            if (fees > 0n)
+                operations.push({
+                    type: "Erc20_Transfer",
+                    sender,
+                    address: NATIVE_ADDRESS,
+                    args: {
+                        amount: fees,
+                        from: sender,
+                        to: bundler,
+                    },
+                });
+        }
+        // Reallocate each vault.
+        operations.push(...Object.entries(reallocations).map(([vault, vaultWithdrawals]) => ({
+            type: "MetaMorpho_PublicReallocate",
+            sender: bundler,
+            address: vault,
+            args: {
+                // Reallocation withdrawals must be sorted by market id in ascending alphabetical order.
+                withdrawals: vaultWithdrawals.sort(({ id: idA }, { id: idB }) => idA > idB ? 1 : -1),
+                supplyMarketId: market.id,
+            },
+        })));
+    }
+    const callback = getValue(mainOperation.args, "callback");
+    const simulatedOperation = {
+        ...mainOperation,
+        args: {
+            ...mainOperation.args,
+            ...(callback && {
+                callback: (data) => {
+                    const operations = callback.flatMap((inputOperation) => {
+                        const subBundleOperations = populateSubBundle(inputOperation, data, options);
+                        // Handle to mutate data (not simulate).
+                        handleBundlerOperations(subBundleOperations, data);
+                        return subBundleOperations;
+                    });
+                    mainOperation.args.callback =
+                        operations;
+                    return [];
+                },
+            }),
+        },
+    };
+    // Operations with callbacks are populated recursively as a side-effect of the simulation, within the callback itself.
+    let requiredTokenAmounts = data.simulateRequiredTokenAmounts(operations.concat([simulatedOperation]));
+    const allOperations = operations.concat([
+        mainOperation,
+    ]);
+    // Skip approvals/transfers if operation only uses available balances (via maxUint256).
+    if (("amount" in mainOperation.args &&
+        mainOperation.args.amount === maxUint256) ||
+        ("assets" in mainOperation.args &&
+            mainOperation.args.assets === maxUint256) ||
+        ("shares" in mainOperation.args && mainOperation.args.shares === maxUint256)) {
+        if (mainOperation.type === "MetaMorpho_Withdraw")
+            mainOperation.args.owner = bundler;
+        return allOperations;
+    }
+    const requirementOperations = getRequirementOperations?.(requiredTokenAmounts) ?? [];
+    requiredTokenAmounts = data.simulateRequiredTokenAmounts(requirementOperations
+        .concat(allOperations)
+        .map((operation) => getSimulatedBundlerOperation(operation)));
+    // Append required input transfers.
+    requiredTokenAmounts.forEach(({ token, required }) => {
+        requirementOperations.push(...populateInputTransfer({
+            type: "Erc20_Transfer",
+            sender: bundler,
+            address: token,
+            args: {
+                amount: required,
+                from: sender,
+                to: bundler,
+            },
+        }, data, { hasSimplePermit: withSimplePermit.has(token) }));
+    });
+    return requirementOperations.concat(allOperations);
+};
+/**
+ * Merges unnecessary duplicate `Erc20_Approve`, `Erc20_Transfer` and `Erc20_Wrap`.
+ * Also redirects `Blue_Borrow|Withdraw|WithdrawCollateral` & `MetaMorpho_Withdraw` operations from the bundler to the receiver,
+ * as long as the tokens received (possibly ERC4626 shares) are not used afterwards in the bundle.
+ * For all the other remaining tokens, appends `Erc20_Transfer` operations to the bundle, from the bundler to the receiver.
+ * @param operations The bundle to optimize.
+ * @param startData The start data from which to simulate th bundle.
+ * @param receiver The receiver of skimmed tokens.
+ * @param unwrapTokens The set of tokens to unwrap before transferring to the receiver.
+ * @param unwrapSlippage The slippage simulated during unwraps. Should never be 0.
+ * @return The optimized bundle.
+ */
+export const finalizeBundle = (operations, startData, receiver, unwrapTokens = new Set(), unwrapSlippage = DEFAULT_SLIPPAGE_TOLERANCE) => {
+    const nbOperations = operations.length;
+    if (nbOperations === 0)
+        return operations;
+    const { bundler } = getChainAddresses(startData.chainId);
+    if (receiver === bundler)
+        throw Error(`receiver is bundler`);
+    const approvals = [];
+    const permits = [];
+    const permit2s = [];
+    const inputTransfers = [];
+    const inputTransfer2s = [];
+    const others = [];
+    // TODO input transfers can be merged to the right-most position where transferred assets are still not used
+    // Merge together approvals, permits, permit2s & input transfers.
+    operations.forEach((operation) => {
+        switch (operation.type) {
+            case "Erc20_Approve": {
+                const duplicateApproval = approvals.find((approval) => approval.address === operation.address &&
+                    approval.sender === operation.sender &&
+                    approval.args.spender === operation.args.spender);
+                if (duplicateApproval == null)
+                    return approvals.push(operation);
+                duplicateApproval.args.amount += operation.args.amount;
+                break;
+            }
+            case "Erc20_Permit": {
+                const duplicatePermit = permits.find((permit) => permit.address === operation.address &&
+                    permit.sender === operation.sender &&
+                    permit.args.spender === operation.args.spender);
+                if (duplicatePermit == null) {
+                    const lastPermit = permits.findLast((permit) => permit.address === operation.address &&
+                        permit.sender === operation.sender);
+                    if (lastPermit)
+                        operation.args.nonce = lastPermit.args.nonce + 1n;
+                    permits.push(operation);
+                }
+                else
+                    duplicatePermit.args.amount += operation.args.amount;
+                break;
+            }
+            case "Erc20_Permit2": {
+                const duplicatePermit2 = permit2s.find((permit2) => permit2.address === operation.address &&
+                    permit2.sender === operation.sender &&
+                    permit2.args.spender === operation.args.spender);
+                if (duplicatePermit2 == null) {
+                    const lastPermit2 = permit2s.findLast((permit2) => permit2.address === operation.address &&
+                        permit2.sender === operation.sender);
+                    if (lastPermit2)
+                        operation.args.nonce = lastPermit2.args.nonce + 1n;
+                    permit2s.push(operation);
+                }
+                else
+                    duplicatePermit2.args.amount += operation.args.amount;
+                break;
+            }
+            case "Erc20_Transfer": {
+                const { address, sender, args: { amount, from, to }, } = operation;
+                if (from !== bundler &&
+                    to === bundler &&
+                    !erc20WrapperTokens[startData.chainId].has(address)) {
+                    const duplicateTransfer = inputTransfers.find((transfer) => transfer.address === address &&
+                        transfer.sender === sender &&
+                        transfer.args.from === from);
+                    if (duplicateTransfer == null ||
+                        // Don't merge the input transfer if from didn't have enough balance at the start.
+                        startData.getHolding(from, address).balance < amount)
+                        return inputTransfers.push(operation);
+                    duplicateTransfer.args.amount += amount;
+                    return;
+                }
+                others.push(operation);
+                break;
+            }
+            case "Erc20_Transfer2": {
+                const { address, sender, args: { amount, from, to }, } = operation;
+                if (from !== bundler && to === bundler) {
+                    const duplicateTransfer2 = inputTransfer2s.find((transfer) => transfer.address === address &&
+                        transfer.sender === sender &&
+                        transfer.args.from === from);
+                    if (duplicateTransfer2 == null ||
+                        // Don't merge the input transfer if from didn't have enough balance at the start.
+                        startData.getHolding(from, address).balance < amount)
+                        return inputTransfer2s.push(operation);
+                    duplicateTransfer2.args.amount += amount;
+                    return;
+                }
+                others.push(operation);
+                break;
+            }
+            // Cannot factorize public reallocations because the liquidity may not always be available before other operations.
+            default:
+                others.push(operation);
+        }
+    });
+    operations = [
+        approvals,
+        permits,
+        permit2s,
+        inputTransfers,
+        inputTransfer2s,
+        others,
+    ].flat(1);
+    let steps = simulateBundlerOperations(operations, startData);
+    // Redirect MetaMorpho deposits.
+    operations.forEach((operation, index) => {
+        if (operation.type !== "MetaMorpho_Deposit" ||
+            operation.args.owner !== bundler)
+            return;
+        const token = operation.address;
+        // shares are not defined when depositing assets, so we rely on simulation steps.
+        const shares = steps[index + 1].getHolding(bundler, token).balance -
+            steps[index].getHolding(bundler, token).balance;
+        if (steps
+            .slice(index + 2)
+            .some((step) => step.getHolding(bundler, token).balance < shares))
+            // If the bundler's balance is at least once lower than assets, the bundler does need these assets.
+            return;
+        operation.args.owner = receiver;
+    });
+    // Redirect borrows, withdrawals & MetaMorpho withdrawals.
+    operations.forEach((operation, index) => {
+        let token;
+        switch (operation.type) {
+            case "Blue_Borrow":
+            case "Blue_Withdraw":
+                token = startData.getMarket(operation.args.id).config.loanToken;
+                break;
+            case "Blue_WithdrawCollateral":
+                token = startData.getMarket(operation.args.id).config.collateralToken;
+                break;
+            case "MetaMorpho_Withdraw":
+                token = startData.getVault(operation.address).asset;
+                break;
+            default:
+                return;
+        }
+        if (operation.args.receiver !== bundler || unwrapTokens.has(token))
+            return;
+        // assets are not defined when using shares, so we rely on simulation steps.
+        const assets = steps[index + 1].getHolding(bundler, token).balance -
+            steps[index].getHolding(bundler, token).balance;
+        if (steps
+            .slice(index + 2)
+            .some((step) => step.getHolding(bundler, token).balance < assets))
+            // If the bundler's balance is at least once lower than assets, the bundler does need these assets.
+            return;
+        operation.args.receiver = receiver;
+    });
+    // Simplify Erc20_Transfer(sender = bundler, to = bundler) + MetaMorpho_Withdraw(owner = bundler) = MetaMorpho_Withdraw(owner = from).
+    operations.forEach((operation, index) => {
+        if (operation.type !== "MetaMorpho_Withdraw" ||
+            operation.args.owner !== bundler)
+            return;
+        // shares are not defined when using assets, so we rely on simulation steps.
+        const shares = steps[index].getHolding(bundler, operation.address).balance -
+            steps[index + 1].getHolding(bundler, operation.address).balance;
+        const inputTransferIndex = operations.findIndex((candidate) => candidate.type === "Erc20_Transfer" &&
+            candidate.address === operation.address &&
+            candidate.sender === bundler &&
+            candidate.args.to === bundler &&
+            candidate.args.amount >= shares);
+        if (inputTransferIndex <= 0)
+            return;
+        const inputTransfer = operations[inputTransferIndex];
+        inputTransfer.args.amount -= shares;
+        operation.args.owner = inputTransfer.args.from;
+    });
+    // Filter out useless input transfers.
+    operations = operations.filter((operation, index) => {
+        if (operation.type !== "Erc20_Transfer")
+            return true;
+        const { amount, from, to } = operation.args;
+        if (from === bundler || to !== bundler)
+            return true;
+        const token = operation.address;
+        if (steps
+            .slice(index + 2)
+            .some((step) => step.getHolding(bundler, token).balance < amount))
+            // If the bundler's balance is at least once less than amount, the bundler does need these assets.
+            // Do not only keep the amount actually used in this case because some input transfers
+            // are expected to be larger to account for slippage.
+            return true;
+        return false;
+    });
+    // Simulate without slippage to skim the bundler of all possible surplus of shares & assets.
+    steps = simulateBundlerOperations(operations, startData, { slippage: 0n });
+    // Unwrap requested remaining wrapped tokens.
+    const unwraps = [];
+    const endBundlerTokenData = getLast(steps).holdings[bundler] ?? {};
+    unwrapTokens.forEach((wrappedToken) => {
+        const remaining = endBundlerTokenData[wrappedToken]?.balance ?? 0n;
+        if (remaining <= 5n)
+            return;
+        const unwrappedToken = getUnwrappedToken(wrappedToken, startData.chainId);
+        if (unwrappedToken == null)
+            return;
+        unwraps.push({
+            type: "Erc20_Unwrap",
+            address: wrappedToken,
+            sender: bundler,
+            args: {
+                amount: maxUint256,
+                receiver,
+                slippage: unwrapSlippage,
+            },
+        });
+    });
+    if (unwraps.length > 0)
+        steps = simulateBundlerOperations(operations.concat(unwraps), startData, {
+            slippage: 0n,
+        });
+    // Skim any token expected to be left on the bundler.
+    const skims = [];
+    {
+        const startBundlerTokenData = steps[0].holdings[bundler] ?? {};
+        const endBundlerTokenData = getLast(steps).holdings[bundler] ?? {};
+        skims.push(...entries(endBundlerTokenData)
+            .filter(([token, { balance }]) => balance - (startBundlerTokenData[token]?.balance ?? 0n) > 5n)
+            .map(([address]) => ({
+            type: "Erc20_Transfer",
+            address,
+            sender: bundler,
+            args: {
+                amount: maxUint256,
+                from: bundler,
+                to: receiver,
+            },
+        })));
+    }
+    return operations.concat(unwraps, skims);
+};
+export const populateBundle = (inputOperations, data, options) => {
+    const steps = [data];
+    let end = data;
+    const operations = inputOperations.flatMap((inputOperation, index) => {
+        try {
+            const subBundleOperations = populateSubBundle(inputOperation, end, options);
+            steps.push((end = getLast(simulateBundlerOperations(subBundleOperations, end))));
+            return subBundleOperations;
+        }
+        catch (error) {
+            if (!(error instanceof Error))
+                throw error;
+            throw new BundlerErrors.Bundle(error, index, inputOperation, steps);
+        }
+    });
+    return { operations, steps };
+};
+export const getSimulatedBundlerOperation = (operation, { slippage } = {}) => {
+    const callback = getValue(operation.args, "callback");
+    const simulatedOperation = {
+        ...operation,
+        args: {
+            ...operation.args,
+            ...(callback && {
+                callback: () => callback.map((operation) => getSimulatedBundlerOperation(operation, { slippage })),
+            }),
+        },
+    };
+    if (slippage != null) {
+        switch (simulatedOperation.type) {
+            case "Erc20_Wrap":
+            case "Erc20_Unwrap":
+            case "Blue_Supply":
+            case "Blue_Withdraw":
+            case "Blue_Borrow":
+            case "Blue_Repay":
+            case "MetaMorpho_Deposit":
+            case "MetaMorpho_Withdraw":
+                simulatedOperation.args.slippage = slippage;
+                break;
+        }
+    }
+    return simulatedOperation;
+};
+export const handleBundlerOperation = (options) => (operation, startData, index) => handleOperation(getSimulatedBundlerOperation(operation, options), startData, index);
+export const handleBundlerOperations = (operations, startData, options) => handleOperations(operations, startData, handleBundlerOperation(options));
+export const simulateBundlerOperation = (options) => (operation, startData, index) => simulateOperation(getSimulatedBundlerOperation(operation, options), startData, index);
+export const simulateBundlerOperations = (operations, startData, options) => handleOperations(operations, startData, simulateBundlerOperation(options));