From be77afbfa57e78968e12a82ea1b165d899cde544 Mon Sep 17 00:00:00 2001
From: antoncoding <antonassocareer@gmail.com>
Date: Sun, 8 Mar 2026 16:41:16 +0800
Subject: [PATCH 1/5] refactor: leverage hook

---
 app/tools/page.tsx                            |  38 +-
 .../leverage/leverageWithErc4626Deposit.ts    | 219 ++++++
 src/hooks/leverage/leverageWithSwap.ts        | 449 +++++++++++
 src/hooks/leverage/math.ts                    |  30 +-
 src/hooks/leverage/transaction-shared.ts      |  55 ++
 src/hooks/useBorrowTransaction.ts             |  23 +-
 src/hooks/useLeverageTransaction.ts           | 732 ++++--------------
 src/hooks/useMultiMarketSupply.ts             |   4 +-
 src/hooks/useSupplyMarket.ts                  |   6 +-
 .../withdraw-collateral-and-repay.tsx         |   2 +-
 .../add-collateral-and-leverage.tsx           |  44 +-
 .../remove-collateral-and-deleverage.tsx      |   6 +-
 12 files changed, 938 insertions(+), 670 deletions(-)
 create mode 100644 src/hooks/leverage/leverageWithErc4626Deposit.ts
 create mode 100644 src/hooks/leverage/leverageWithSwap.ts
 create mode 100644 src/hooks/leverage/transaction-shared.ts

diff --git a/app/tools/page.tsx b/app/tools/page.tsx
index 998b78c2..c4eff89c 100644
--- a/app/tools/page.tsx
+++ b/app/tools/page.tsx
@@ -12,7 +12,7 @@ import { useMorphoAuthorization } from '@/hooks/useMorphoAuthorization';
 import { useStyledToast } from '@/hooks/useStyledToast';
 import { toUserFacingTransactionErrorMessage } from '@/utils/transaction-errors';
 import { getBundlerV2, MONARCH_TX_IDENTIFIER } from '@/utils/morpho';
-import { getNetworkName, SupportedNetworks } from '@/utils/networks';
+import { getNetworkName, type SupportedNetworks } from '@/utils/networks';
 import NetworkFilter from '@/features/markets/components/filters/network-filter';
 
 export default function ToolsPage() {
@@ -159,14 +159,16 @@ export default function ToolsPage() {
       }) + MONARCH_TX_IDENTIFIER) as `0x${string}`,
       value: 0n,
       chainId: selectedChainId,
-    }).catch((error: unknown) => {
-      const userFacingMessage = toUserFacingTransactionErrorMessage(error, 'Failed to submit Bundler V2 asset sweep.');
-      if (userFacingMessage !== 'User rejected transaction.') {
-        toast.error('Asset sweep failed', userFacingMessage);
-      }
-    }).finally(() => {
-      setIsSweepConfirmModalOpen(false);
-    });
+    })
+      .catch((error: unknown) => {
+        const userFacingMessage = toUserFacingTransactionErrorMessage(error, 'Failed to submit Bundler V2 asset sweep.');
+        if (userFacingMessage !== 'User rejected transaction.') {
+          toast.error('Asset sweep failed', userFacingMessage);
+        }
+      })
+      .finally(() => {
+        setIsSweepConfirmModalOpen(false);
+      });
   };
 
   const getInputClassName = () => {
@@ -277,9 +279,7 @@ export default function ToolsPage() {
                   Executes via Bundler V2 multicall on the selected network:
                   <code className="mx-1 rounded bg-hovered px-1 py-0.5 text-xs">erc20Transfer(asset, yourWallet, maxUint256)</code>.
                 </p>
-                <p className="text-sm text-red-500">
-                  ⚠️ This transfers only what Bundler V2 already holds for the asset address.
-                </p>
+                <p className="text-sm text-red-500">⚠️ This transfers only what Bundler V2 already holds for the asset address.</p>
               </div>
 
               <div className="flex flex-col gap-3">
@@ -292,7 +292,10 @@ export default function ToolsPage() {
                   />
                 </div>
                 <div className="flex flex-col gap-2">
-                  <label htmlFor="bundler-asset-address" className="text-xs text-secondary">
+                  <label
+                    htmlFor="bundler-asset-address"
+                    className="text-xs text-secondary"
+                  >
                     Asset address
                   </label>
                   <input
@@ -315,9 +318,7 @@ export default function ToolsPage() {
                   <p>
                     Network: {getNetworkName(selectedChainId)} ({selectedChainId})
                   </p>
-                  <p>
-                    Bundler V2: {bundlerV2Address === zeroAddress ? 'Not configured' : bundlerV2Address}
-                  </p>
+                  <p>Bundler V2: {bundlerV2Address === zeroAddress ? 'Not configured' : bundlerV2Address}</p>
                   <p>Recipient: {account ?? 'Connect wallet'}</p>
                 </div>
 
@@ -360,7 +361,10 @@ export default function ToolsPage() {
               </div>
             </ModalBody>
             <ModalFooter>
-              <Button variant="default" onClick={onClose}>
+              <Button
+                variant="default"
+                onClick={onClose}
+              >
                 Cancel
               </Button>
               <Button
diff --git a/src/hooks/leverage/leverageWithErc4626Deposit.ts b/src/hooks/leverage/leverageWithErc4626Deposit.ts
new file mode 100644
index 00000000..c3d4e8e3
--- /dev/null
+++ b/src/hooks/leverage/leverageWithErc4626Deposit.ts
@@ -0,0 +1,219 @@
+import { type Address, encodeAbiParameters, encodeFunctionData, maxUint256 } from 'viem';
+import morphoBundlerAbi from '@/abis/bundlerV2';
+import { LEVERAGE_FEE_RECIPIENT } from '@/config/leverage';
+import { MONARCH_TX_IDENTIFIER } from '@/utils/morpho';
+import type { Market } from '@/utils/types';
+import { getBorrowSharesSlippageAmount, withSlippageFloor } from './math';
+import {
+  type EnsureLeverageAuthorization,
+  type LeverageMarketParams,
+  type LeverageStepType,
+  type SendLeverageTransaction,
+  type SignForLeverageBundlers,
+  sleep,
+} from './transaction-shared';
+import type { Erc4626LeverageRoute } from './types';
+
+type LeverageWithErc4626DepositParams = {
+  account: Address;
+  bundlerAddress: Address;
+  market: Market;
+  marketParams: LeverageMarketParams;
+  route: Erc4626LeverageRoute;
+  collateralAmount: bigint;
+  collateralAmountInCollateralToken: bigint;
+  inputTokenAddress: Address;
+  inputTokenAmountForTransfer: bigint;
+  isLoanAssetInput: boolean;
+  flashCollateralAmount: bigint;
+  flashLoanAmount: bigint; // amount to flashloan in loan asset
+  leverageFeeAmount: bigint;
+  usePermit2: boolean;
+  permit2Authorized: boolean;
+  isBundlerAuthorized: boolean | undefined;
+  authorizePermit2: () => Promise<unknown>;
+  ensureBundlerAuthorization: EnsureLeverageAuthorization;
+  signForBundlers: SignForLeverageBundlers;
+  isApproved: boolean;
+  approve: () => Promise<unknown>;
+  updateStep: (step: LeverageStepType) => void;
+  sendTransactionAsync: SendLeverageTransaction;
+};
+
+export const leverageWithErc4626Deposit = async ({
+  account,
+  bundlerAddress,
+  market,
+  marketParams,
+  route,
+  collateralAmount,
+  collateralAmountInCollateralToken,
+  inputTokenAddress,
+  inputTokenAmountForTransfer,
+  isLoanAssetInput,
+  flashCollateralAmount,
+  flashLoanAmount,
+  leverageFeeAmount,
+  usePermit2,
+  permit2Authorized,
+  isBundlerAuthorized,
+  authorizePermit2,
+  ensureBundlerAuthorization,
+  signForBundlers,
+  isApproved,
+  approve,
+  updateStep,
+  sendTransactionAsync,
+}: LeverageWithErc4626DepositParams): Promise<void> => {
+  const txs: `0x${string}`[] = [];
+
+  if (usePermit2) {
+    if (!permit2Authorized) {
+      updateStep('approve_permit2');
+      await authorizePermit2();
+      await sleep(800);
+    }
+
+    if (!isBundlerAuthorized) {
+      updateStep('authorize_bundler_sig');
+    }
+
+    const { authorized, authorizationTxData } = await ensureBundlerAuthorization({ mode: 'signature' });
+    if (!authorized) {
+      throw new Error('Failed to authorize Bundler via signature.');
+    }
+    if (isBundlerAuthorized && authorizationTxData) {
+      throw new Error('Authorization state changed. Please retry leverage.');
+    }
+    if (authorizationTxData) {
+      txs.push(authorizationTxData);
+      await sleep(800);
+    }
+
+    updateStep('sign_permit');
+    const { sigs, permitSingle } = await signForBundlers();
+    txs.push(
+      encodeFunctionData({
+        abi: morphoBundlerAbi,
+        functionName: 'approve2',
+        args: [permitSingle, sigs, false],
+      }),
+    );
+  } else {
+    if (!isBundlerAuthorized) {
+      updateStep('authorize_bundler_tx');
+      const { authorized } = await ensureBundlerAuthorization({ mode: 'transaction' });
+      if (!authorized) {
+        throw new Error('Failed to authorize Bundler via transaction.');
+      }
+    }
+
+    if (!isApproved) {
+      updateStep('approve_token');
+      await approve();
+      await sleep(900);
+    }
+  }
+
+  // Asset-based borrow uses an exact asset amount plus a max-share slippage bound.
+  const borrowSharesSlippageAmount = getBorrowSharesSlippageAmount({
+    borrowAssets: flashLoanAmount,
+    totalBorrowAssets: BigInt(market.state.borrowAssets),
+    totalBorrowShares: BigInt(market.state.borrowShares),
+  });
+
+  if (inputTokenAmountForTransfer > 0n) {
+    txs.push(
+      encodeFunctionData({
+        abi: morphoBundlerAbi,
+        functionName: usePermit2 ? 'transferFrom2' : 'erc20TransferFrom',
+        args: [inputTokenAddress, inputTokenAmountForTransfer],
+      }),
+    );
+  }
+
+  if (isLoanAssetInput) {
+    // WHY: this lets users start with loan-token underlying for ERC4626 markets.
+    // We mint shares first so all leverage math and downstream Morpho collateral is in share units.
+    txs.push(
+      encodeFunctionData({
+        abi: morphoBundlerAbi,
+        functionName: 'erc4626Deposit',
+        args: [route.collateralVault, collateralAmount, withSlippageFloor(collateralAmountInCollateralToken), bundlerAddress],
+      }),
+    );
+  }
+
+  const callbackTxs: `0x${string}`[] = [
+    encodeFunctionData({
+      abi: morphoBundlerAbi,
+      functionName: 'erc4626Deposit',
+      args: [route.collateralVault, flashLoanAmount, withSlippageFloor(flashCollateralAmount), bundlerAddress],
+    }),
+  ];
+
+  // leverage fee is always in collateral unit.
+  if (leverageFeeAmount > 0n) {
+    callbackTxs.push(
+      encodeFunctionData({
+        abi: morphoBundlerAbi,
+        functionName: 'erc20Transfer',
+        args: [market.collateralAsset.address as Address, LEVERAGE_FEE_RECIPIENT, leverageFeeAmount],
+      }),
+    );
+  }
+
+  callbackTxs.push(
+    encodeFunctionData({
+      abi: morphoBundlerAbi,
+      functionName: 'morphoSupplyCollateral',
+      args: [marketParams, maxUint256, account, '0x'],
+    }),
+  );
+
+  callbackTxs.push(
+    encodeFunctionData({
+      abi: morphoBundlerAbi,
+      functionName: 'morphoBorrow',
+      args: [marketParams, flashLoanAmount, 0n, borrowSharesSlippageAmount, bundlerAddress],
+    }),
+  );
+
+  const flashLoanCallbackData = encodeAbiParameters([{ type: 'bytes[]' }], [callbackTxs]);
+  txs.push(
+    encodeFunctionData({
+      abi: morphoBundlerAbi,
+      functionName: 'morphoFlashLoan',
+      args: [market.loanAsset.address as Address, flashLoanAmount, flashLoanCallbackData],
+    }),
+  );
+  // Safety net: sweep any residual loan/collateral balances from bundler to the user.
+  txs.push(
+    encodeFunctionData({
+      abi: morphoBundlerAbi,
+      functionName: 'erc20Transfer',
+      args: [market.loanAsset.address as Address, account, maxUint256],
+    }),
+  );
+  txs.push(
+    encodeFunctionData({
+      abi: morphoBundlerAbi,
+      functionName: 'erc20Transfer',
+      args: [market.collateralAsset.address as Address, account, maxUint256],
+    }),
+  );
+
+  updateStep('execute');
+  await sleep(500);
+
+  await sendTransactionAsync({
+    account,
+    to: bundlerAddress,
+    data: (encodeFunctionData({
+      abi: morphoBundlerAbi,
+      functionName: 'multicall',
+      args: [txs],
+    }) + MONARCH_TX_IDENTIFIER) as `0x${string}`,
+    value: 0n,
+  });
+};
diff --git a/src/hooks/leverage/leverageWithSwap.ts b/src/hooks/leverage/leverageWithSwap.ts
new file mode 100644
index 00000000..63a8516c
--- /dev/null
+++ b/src/hooks/leverage/leverageWithSwap.ts
@@ -0,0 +1,449 @@
+import { type Address, encodeFunctionData, isAddress, isAddressEqual, keccak256, maxUint256, zeroHash } from 'viem';
+import { bundlerV3Abi } from '@/abis/bundlerV3';
+import morphoAbi from '@/abis/morpho';
+import { morphoGeneralAdapterV1Abi } from '@/abis/morphoGeneralAdapterV1';
+import { paraswapAdapterAbi } from '@/abis/paraswapAdapter';
+import permit2Abi from '@/abis/permit2';
+import { LEVERAGE_FEE_RECIPIENT } from '@/config/leverage';
+import { buildVeloraTransactionPayload, isVeloraRateChangedError, type VeloraPriceRoute } from '@/features/swap/api/velora';
+import { getMorphoAddress, MONARCH_TX_IDENTIFIER } from '@/utils/morpho';
+import { PERMIT2_ADDRESS } from '@/utils/permit2';
+import type { Market } from '@/utils/types';
+import { type Bundler3Call, encodeBundler3Calls, getParaswapSellOffsets, readCalldataUint256 } from './bundler3';
+import {
+  type EnsureLeverageAuthorization,
+  type LeverageMarketParams,
+  type LeverageStepType,
+  type SendLeverageTransaction,
+  type SignForLeverageBundlers,
+  sleep,
+} from './transaction-shared';
+import type { SwapLeverageRoute } from './types';
+import { isVeloraBypassablePrecheckError } from './velora-precheck';
+
+type LeverageWithSwapParams = {
+  account: Address;
+  bundlerAddress: Address;
+  market: Market;
+  marketParams: LeverageMarketParams;
+  route: SwapLeverageRoute;
+  inputTokenAddress: Address;
+  inputTokenAmountForTransfer: bigint;
+  isLoanAssetInput: boolean;
+  flashLoanAmount: bigint;
+  flashCollateralAmount: bigint;
+  totalAddedCollateral: bigint;
+  leverageFeeAmount: bigint;
+  swapPriceRoute: VeloraPriceRoute;
+  slippageBps: number;
+  usePermit2: boolean;
+  permit2Authorized: boolean;
+  isBundlerAuthorized: boolean | undefined;
+  authorizePermit2: () => Promise<unknown>;
+  ensureBundlerAuthorization: EnsureLeverageAuthorization;
+  signForBundlers: SignForLeverageBundlers;
+  isApproved: boolean;
+  approve: () => Promise<unknown>;
+  updateStep: (step: LeverageStepType) => void;
+  sendTransactionAsync: SendLeverageTransaction;
+};
+
+const buildSwapTransactionPayload = async ({
+  market,
+  route,
+  totalLoanSellAmount,
+  swapPriceRoute,
+  slippageBps,
+}: {
+  market: Market;
+  route: SwapLeverageRoute;
+  totalLoanSellAmount: bigint;
+  swapPriceRoute: VeloraPriceRoute;
+  slippageBps: number;
+}) => {
+  const buildPayload = async (ignoreChecks: boolean) =>
+    buildVeloraTransactionPayload({
+      srcToken: market.loanAsset.address,
+      srcDecimals: market.loanAsset.decimals,
+      destToken: market.collateralAsset.address,
+      destDecimals: market.collateralAsset.decimals,
+      srcAmount: totalLoanSellAmount,
+      network: market.morphoBlue.chain.id,
+      userAddress: route.paraswapAdapterAddress,
+      priceRoute: swapPriceRoute,
+      slippageBps,
+      ignoreChecks,
+    });
+
+  try {
+    return await buildPayload(false);
+  } catch (buildError: unknown) {
+    if (isVeloraRateChangedError(buildError)) {
+      throw new Error('Leverage quote changed. Please review the updated preview and try again.');
+    }
+
+    if (
+      !isVeloraBypassablePrecheckError({
+        error: buildError,
+        sourceTokenAddress: market.loanAsset.address,
+        sourceTokenSymbol: market.loanAsset.symbol,
+      })
+    ) {
+      throw buildError;
+    }
+
+    try {
+      return await buildPayload(true);
+    } catch (fallbackBuildError: unknown) {
+      if (isVeloraRateChangedError(fallbackBuildError)) {
+        throw new Error('Leverage quote changed. Please review the updated preview and try again.');
+      }
+
+      throw fallbackBuildError;
+    }
+  }
+};
+
+export const leverageWithSwap = async ({
+  account,
+  bundlerAddress,
+  market,
+  marketParams,
+  route,
+  inputTokenAddress,
+  inputTokenAmountForTransfer,
+  isLoanAssetInput,
+  flashLoanAmount,
+  flashCollateralAmount,
+  totalAddedCollateral,
+  leverageFeeAmount,
+  swapPriceRoute,
+  slippageBps,
+  usePermit2,
+  permit2Authorized,
+  isBundlerAuthorized,
+  authorizePermit2,
+  ensureBundlerAuthorization,
+  signForBundlers,
+  isApproved,
+  approve,
+  updateStep,
+  sendTransactionAsync,
+}: LeverageWithSwapParams): Promise<void> => {
+  if (!Number.isFinite(slippageBps) || slippageBps <= 0) {
+    throw new Error('Invalid slippage tolerance. Please set a positive slippage value.');
+  }
+
+  const preFlashCollateralFee =
+    !isLoanAssetInput && inputTokenAmountForTransfer > 0n
+      ? leverageFeeAmount < inputTokenAmountForTransfer
+        ? leverageFeeAmount
+        : inputTokenAmountForTransfer
+      : 0n;
+  const callbackCollateralFee = leverageFeeAmount - preFlashCollateralFee;
+  const preFlashCollateralSupplyAmount = inputTokenAmountForTransfer - preFlashCollateralFee;
+  const totalLoanSellAmount = isLoanAssetInput ? inputTokenAmountForTransfer + flashLoanAmount : flashLoanAmount;
+  if (totalLoanSellAmount <= 0n) {
+    throw new Error('Invalid total sell amount for swap-backed leverage.');
+  }
+
+  let authorizationCall: Bundler3Call | null = null;
+  let permit2Call: Bundler3Call | null = null;
+
+  if (usePermit2) {
+    if (!permit2Authorized) {
+      updateStep('approve_permit2');
+      await authorizePermit2();
+      await sleep(800);
+    }
+
+    if (!isBundlerAuthorized) {
+      updateStep('authorize_bundler_sig');
+    }
+
+    const { authorized, authorizationTxData, authorizationSignatureData } = await ensureBundlerAuthorization({ mode: 'signature' });
+    if (!authorized) {
+      throw new Error('Failed to authorize Bundler via signature.');
+    }
+    if (isBundlerAuthorized && authorizationTxData) {
+      throw new Error('Authorization state changed. Please retry leverage.');
+    }
+    if (authorizationTxData) {
+      if (!authorizationSignatureData) {
+        throw new Error('Missing Morpho authorization signature payload for swap-backed leverage.');
+      }
+
+      authorizationCall = {
+        to: getMorphoAddress(market.morphoBlue.chain.id) as Address,
+        data: encodeFunctionData({
+          abi: morphoAbi,
+          functionName: 'setAuthorizationWithSig',
+          args: [authorizationSignatureData.authorization, authorizationSignatureData.signature],
+        }),
+        value: 0n,
+        skipRevert: false,
+        callbackHash: zeroHash,
+      };
+      await sleep(800);
+    }
+
+    updateStep('sign_permit');
+    const { sigs, permitSingle } = await signForBundlers();
+    permit2Call = {
+      to: PERMIT2_ADDRESS,
+      data: encodeFunctionData({
+        abi: permit2Abi,
+        functionName: 'permit',
+        args: [account, permitSingle, sigs],
+      }),
+      value: 0n,
+      skipRevert: false,
+      callbackHash: zeroHash,
+    };
+  } else {
+    if (!isBundlerAuthorized) {
+      updateStep('authorize_bundler_tx');
+      const { authorized } = await ensureBundlerAuthorization({ mode: 'transaction' });
+      if (!authorized) {
+        throw new Error('Failed to authorize Bundler via transaction.');
+      }
+    }
+
+    if (!isApproved) {
+      updateStep('approve_token');
+      await approve();
+      await sleep(900);
+    }
+  }
+
+  const swapTxPayload = await buildSwapTransactionPayload({
+    market,
+    route,
+    totalLoanSellAmount,
+    swapPriceRoute,
+    slippageBps,
+  });
+
+  const trustedVeloraTargets = [swapPriceRoute.contractAddress, swapPriceRoute.tokenTransferProxy].filter(
+    (candidate): candidate is Address => typeof candidate === 'string' && isAddress(candidate),
+  );
+  if (trustedVeloraTargets.length === 0 || !trustedVeloraTargets.some((target) => isAddressEqual(swapTxPayload.to, target))) {
+    throw new Error('Leverage quote changed. Please review the updated preview and try again.');
+  }
+
+  const expectedCollateralOut = isLoanAssetInput ? totalAddedCollateral : flashCollateralAmount;
+  if (expectedCollateralOut <= 0n) {
+    throw new Error('Velora returned zero collateral output for leverage swap.');
+  }
+
+  const sellOffsets = getParaswapSellOffsets(swapTxPayload.data);
+  const quotedSellAmount = BigInt(swapPriceRoute.srcAmount);
+  const calldataSellAmount = readCalldataUint256(swapTxPayload.data, sellOffsets.exactAmount);
+  const calldataMinCollateralOut = readCalldataUint256(swapTxPayload.data, sellOffsets.limitAmount);
+  if (
+    quotedSellAmount !== totalLoanSellAmount ||
+    calldataSellAmount !== totalLoanSellAmount ||
+    calldataMinCollateralOut !== expectedCollateralOut
+  ) {
+    throw new Error('Leverage quote changed. Please review the updated preview and try again.');
+  }
+
+  const callbackBundle: Bundler3Call[] = [
+    // put asset into parapswap adapter for swapping.
+    {
+      to: route.generalAdapterAddress,
+      data: encodeFunctionData({
+        abi: morphoGeneralAdapterV1Abi,
+        functionName: 'erc20Transfer',
+        args: [market.loanAsset.address as Address, route.paraswapAdapterAddress, totalLoanSellAmount],
+      }),
+      value: 0n,
+      skipRevert: false,
+      callbackHash: zeroHash,
+    },
+    {
+      to: route.paraswapAdapterAddress,
+      data: encodeFunctionData({
+        abi: paraswapAdapterAbi,
+        functionName: 'sell',
+        args: [
+          swapTxPayload.to,
+          swapTxPayload.data,
+          market.loanAsset.address as Address,
+          market.collateralAsset.address as Address,
+          false,
+          sellOffsets,
+          route.generalAdapterAddress,
+        ],
+      }),
+      value: 0n,
+      skipRevert: false,
+      callbackHash: zeroHash,
+    },
+  ];
+
+  if (callbackCollateralFee > 0n) {
+    callbackBundle.push({
+      to: route.generalAdapterAddress,
+      data: encodeFunctionData({
+        abi: morphoGeneralAdapterV1Abi,
+        functionName: 'erc20Transfer',
+        args: [market.collateralAsset.address as Address, LEVERAGE_FEE_RECIPIENT, callbackCollateralFee],
+      }),
+      value: 0n,
+      skipRevert: false,
+      callbackHash: zeroHash,
+    });
+  }
+
+  callbackBundle.push(
+    {
+      to: route.generalAdapterAddress,
+      data: encodeFunctionData({
+        abi: morphoGeneralAdapterV1Abi,
+        functionName: 'morphoSupplyCollateral',
+        args: [marketParams, maxUint256, account, '0x'],
+      }),
+      value: 0n,
+      skipRevert: false,
+      callbackHash: zeroHash,
+    },
+    {
+      to: route.generalAdapterAddress,
+      data: encodeFunctionData({
+        abi: morphoGeneralAdapterV1Abi,
+        functionName: 'morphoBorrow',
+        // receive the flashloan in general adapter address
+        args: [marketParams, flashLoanAmount, 0n, 0n, route.generalAdapterAddress],
+      }),
+      value: 0n,
+      skipRevert: false,
+      callbackHash: zeroHash,
+    },
+  );
+  const callbackBundleData = encodeBundler3Calls(callbackBundle);
+
+  const bundleCalls: Bundler3Call[] = [];
+  if (authorizationCall) {
+    bundleCalls.push(authorizationCall);
+  }
+  if (permit2Call) {
+    bundleCalls.push(permit2Call);
+  }
+
+  if (inputTokenAmountForTransfer > 0n) {
+    bundleCalls.push({
+      to: route.generalAdapterAddress,
+      data: encodeFunctionData({
+        abi: morphoGeneralAdapterV1Abi,
+        functionName: usePermit2 ? 'permit2TransferFrom' : 'erc20TransferFrom',
+        args: [inputTokenAddress, route.generalAdapterAddress, inputTokenAmountForTransfer],
+      }),
+      value: 0n,
+      skipRevert: false,
+      callbackHash: zeroHash,
+    });
+
+    if (!isLoanAssetInput) {
+      if (preFlashCollateralFee > 0n) {
+        bundleCalls.push({
+          to: route.generalAdapterAddress,
+          data: encodeFunctionData({
+            abi: morphoGeneralAdapterV1Abi,
+            functionName: 'erc20Transfer',
+            args: [market.collateralAsset.address as Address, LEVERAGE_FEE_RECIPIENT, preFlashCollateralFee],
+          }),
+          value: 0n,
+          skipRevert: false,
+          callbackHash: zeroHash,
+        });
+      }
+      if (preFlashCollateralSupplyAmount > 0n) {
+        bundleCalls.push({
+          to: route.generalAdapterAddress,
+          data: encodeFunctionData({
+            abi: morphoGeneralAdapterV1Abi,
+            functionName: 'morphoSupplyCollateral',
+            args: [marketParams, preFlashCollateralSupplyAmount, account, '0x'],
+          }),
+          value: 0n,
+          skipRevert: false,
+          callbackHash: zeroHash,
+        });
+      }
+    }
+  }
+
+  bundleCalls.push({
+    to: route.generalAdapterAddress,
+    data: encodeFunctionData({
+      abi: morphoGeneralAdapterV1Abi,
+      functionName: 'morphoFlashLoan',
+      args: [market.loanAsset.address as Address, flashLoanAmount, callbackBundleData],
+    }),
+    value: 0n,
+    skipRevert: false,
+    callbackHash: keccak256(callbackBundleData),
+  });
+  // Safety net: sweep any residual loan/collateral balances from adapters to the user.
+  bundleCalls.push(
+    {
+      to: route.generalAdapterAddress,
+      data: encodeFunctionData({
+        abi: morphoGeneralAdapterV1Abi,
+        functionName: 'erc20Transfer',
+        args: [market.loanAsset.address as Address, account, maxUint256],
+      }),
+      value: 0n,
+      skipRevert: false,
+      callbackHash: zeroHash,
+    },
+    {
+      to: route.generalAdapterAddress,
+      data: encodeFunctionData({
+        abi: morphoGeneralAdapterV1Abi,
+        functionName: 'erc20Transfer',
+        args: [market.collateralAsset.address as Address, account, maxUint256],
+      }),
+      value: 0n,
+      skipRevert: false,
+      callbackHash: zeroHash,
+    },
+    {
+      to: route.paraswapAdapterAddress,
+      data: encodeFunctionData({
+        abi: paraswapAdapterAbi,
+        functionName: 'erc20Transfer',
+        args: [market.loanAsset.address as Address, account, maxUint256],
+      }),
+      value: 0n,
+      skipRevert: false,
+      callbackHash: zeroHash,
+    },
+    {
+      to: route.paraswapAdapterAddress,
+      data: encodeFunctionData({
+        abi: paraswapAdapterAbi,
+        functionName: 'erc20Transfer',
+        args: [market.collateralAsset.address as Address, account, maxUint256],
+      }),
+      value: 0n,
+      skipRevert: false,
+      callbackHash: zeroHash,
+    },
+  );
+
+  updateStep('execute');
+  await sleep(800);
+
+  await sendTransactionAsync({
+    account,
+    to: bundlerAddress,
+    data: (encodeFunctionData({
+      abi: bundlerV3Abi,
+      functionName: 'multicall',
+      args: [bundleCalls],
+    }) + MONARCH_TX_IDENTIFIER) as `0x${string}`,
+    value: 0n,
+  });
+};
diff --git a/src/hooks/leverage/math.ts b/src/hooks/leverage/math.ts
index 248a342d..99c53a85 100644
--- a/src/hooks/leverage/math.ts
+++ b/src/hooks/leverage/math.ts
@@ -4,6 +4,9 @@ import { LEVERAGE_MIN_MULTIPLIER_BPS, LEVERAGE_MULTIPLIER_SCALE_BPS } from './ty
 export const LEVERAGE_SLIPPAGE_BUFFER_BPS = 9_950n; // 0.50% tolerance
 export const BPS_SCALE = 10_000n;
 export const WAD_TO_BPS_SCALE = 100_000_000_000_000n;
+const ASSET_INPUT_SHARE_SLIPPAGE_BUFFER_BPS = 50n; // 0.50%
+const MORPHO_VIRTUAL_SHARES = 1_000_000n;
+const MORPHO_VIRTUAL_ASSETS = 1n;
 const DEFAULT_SLIPPAGE_TOLERANCE_BPS = BPS_SCALE - LEVERAGE_SLIPPAGE_BUFFER_BPS;
 const MAX_TARGET_LTV_BPS = BPS_SCALE - 1n;
 const COMPACT_AMOUNT_LOCALE = 'en-US';
@@ -364,7 +367,13 @@ export const withSlippageCeil = (value: bigint, slippageBps?: number): bigint =>
   return (value * ceilBps + LEVERAGE_MULTIPLIER_SCALE_BPS - 1n) / LEVERAGE_MULTIPLIER_SCALE_BPS;
 };
 
-export const computeBorrowSharesWithBuffer = ({
+/**
+ * Returns the slippage bound for asset-based `morphoBorrow` calls.
+ *
+ * This intentionally overestimates the borrow shares that may be minted for a fixed
+ * asset input. It is only for the bundler slippage parameter, not for previews.
+ */
+export const getBorrowSharesSlippageAmount = ({
   borrowAssets,
   totalBorrowAssets,
   totalBorrowShares,
@@ -375,16 +384,11 @@ export const computeBorrowSharesWithBuffer = ({
 }): bigint => {
   if (borrowAssets <= 0n) return 0n;
 
-  // Morpho virtual shares/assets from SharesMathLib to avoid edge-case division by zero.
-  const VIRTUAL_SHARES = 1_000_000n;
-  const VIRTUAL_ASSETS = 1n;
-
-  const denominator = totalBorrowAssets + VIRTUAL_ASSETS;
-  const numerator = borrowAssets * (totalBorrowShares + VIRTUAL_SHARES);
+  const denominator = totalBorrowAssets + MORPHO_VIRTUAL_ASSETS;
+  const numerator = borrowAssets * (totalBorrowShares + MORPHO_VIRTUAL_SHARES);
   const expectedShares = (numerator + denominator - 1n) / denominator; // round up
 
-  // Add 0.5% headroom to keep borrow slippage checks stable across minor state drift.
-  return expectedShares + expectedShares / 200n + 1n;
+  return expectedShares + (expectedShares * ASSET_INPUT_SHARE_SLIPPAGE_BUFFER_BPS) / BPS_SCALE + 1n;
 };
 
 export const computeRepaySharesWithBuffer = ({
@@ -400,5 +404,11 @@ export const computeRepaySharesWithBuffer = ({
 
   const numerator = repayAssets * totalBorrowShares;
   const expectedShares = (numerator + totalBorrowAssets - 1n) / totalBorrowAssets; // round up
-  return expectedShares + expectedShares / 200n + 1n;
+  return expectedShares + (expectedShares * ASSET_INPUT_SHARE_SLIPPAGE_BUFFER_BPS) / BPS_SCALE + 1n;
 };
+
+/**
+ * Asset-based supply/deposit flows use a minimum-share slippage floor instead of a
+ * share estimate. `1n` means "accept any positive share output".
+ */
+export const MIN_SHARES_SLIPPAGE_AMOUNT = 1n;
diff --git a/src/hooks/leverage/transaction-shared.ts b/src/hooks/leverage/transaction-shared.ts
new file mode 100644
index 00000000..6f8a0b1c
--- /dev/null
+++ b/src/hooks/leverage/transaction-shared.ts
@@ -0,0 +1,55 @@
+import type { Address } from 'viem';
+import type { MorphoAuthorizationSignatureData } from '@/hooks/useMorphoAuthorization';
+import type { Market } from '@/utils/types';
+
+export type LeverageStepType =
+  | 'approve_permit2'
+  | 'authorize_bundler_sig'
+  | 'sign_permit'
+  | 'authorize_bundler_tx'
+  | 'approve_token'
+  | 'execute';
+
+export type LeverageMarketParams = {
+  loanToken: Address;
+  collateralToken: Address;
+  oracle: Address;
+  irm: Address;
+  lltv: bigint;
+};
+
+type AuthorizationMode = 'signature' | 'transaction';
+
+export type EnsureLeverageAuthorization = (params: { mode: AuthorizationMode }) => Promise<{
+  authorized: boolean;
+  authorizationTxData: `0x${string}` | null;
+  authorizationSignatureData: MorphoAuthorizationSignatureData | null;
+}>;
+
+export type Permit2LeverageSignature = {
+  sigs: `0x${string}`;
+  permitSingle: {
+    details: {
+      token: Address;
+      amount: bigint;
+      expiration: number;
+      nonce: number;
+    };
+    spender: Address;
+    sigDeadline: bigint;
+  };
+};
+
+export type SignForLeverageBundlers = () => Promise<Permit2LeverageSignature>;
+
+export type SendLeverageTransaction = (params: { account: Address; to: Address; data: `0x${string}`; value: bigint }) => Promise<unknown>;
+
+export const buildLeverageMarketParams = (market: Market): LeverageMarketParams => ({
+  loanToken: market.loanAsset.address as Address,
+  collateralToken: market.collateralAsset.address as Address,
+  oracle: market.oracleAddress as Address,
+  irm: market.irmAddress as Address,
+  lltv: BigInt(market.lltv),
+});
+
+export const sleep = (ms: number): Promise<void> => new Promise((resolve) => setTimeout(resolve, ms));
diff --git a/src/hooks/useBorrowTransaction.ts b/src/hooks/useBorrowTransaction.ts
index 74759338..279e6b71 100644
--- a/src/hooks/useBorrowTransaction.ts
+++ b/src/hooks/useBorrowTransaction.ts
@@ -6,6 +6,7 @@ import { formatBalance } from '@/utils/balance';
 import { getBundlerV2, MONARCH_TX_IDENTIFIER } from '@/utils/morpho';
 import { isUserRejectedTransactionError, toUserFacingTransactionErrorMessage } from '@/utils/transaction-errors';
 import type { Market } from '@/utils/types';
+import { getBorrowSharesSlippageAmount } from './leverage/math';
 import { useERC20Approval } from './useERC20Approval';
 import { useBundlerAuthorizationStep } from './useBundlerAuthorizationStep';
 import { usePermit2 } from './usePermit2';
@@ -132,20 +133,12 @@ export function useBorrowTransaction({ market, collateralAmount, borrowAmount, o
 
   // Core transaction execution logic
   const executeBorrowTransaction = useCallback(async () => {
-    // Morpho virtual shares/assets (from SharesMathLib.sol) - prevents division by zero on fresh markets
-    const VIRTUAL_SHARES = 1000000n; // 1e6
-    const VIRTUAL_ASSETS = 1n;
-
-    // Calculate max borrow shares using Morpho's formula with 0.5% slippage buffer
-    // Formula: shares = assets * (totalShares + VIRTUAL_SHARES) / (totalAssets + VIRTUAL_ASSETS)
-    const totalBorrowShares = BigInt(market.state.borrowShares);
-    const totalBorrowAssets = BigInt(market.state.borrowAssets);
-    const denominator = totalBorrowAssets + VIRTUAL_ASSETS;
-    const numerator = borrowAmount * (totalBorrowShares + VIRTUAL_SHARES);
-    // Round up: (a + b - 1) / b
-    const expectedShares = borrowAmount === 0n ? 0n : (numerator + denominator - 1n) / denominator;
-    // Add 0.5% buffer + 1 for safety margin
-    const maxBorrowShares = borrowAmount === 0n ? 0n : expectedShares + expectedShares / 200n + 1n;
+    // Asset-based borrow uses an exact asset amount plus a max-share slippage bound.
+    const borrowSharesSlippageAmount = getBorrowSharesSlippageAmount({
+      borrowAssets: borrowAmount,
+      totalBorrowAssets: BigInt(market.state.borrowAssets),
+      totalBorrowShares: BigInt(market.state.borrowShares),
+    });
 
     try {
       const transactions: `0x${string}`[] = [];
@@ -284,7 +277,7 @@ export function useBorrowTransaction({ market, collateralAmount, borrowAmount, o
             },
             borrowAmount, // asset to borrow
             0n, // shares to mint (0), we always use `assets` as param
-            maxBorrowShares, // slippageAmount: max borrow shares to mint
+            borrowSharesSlippageAmount,
             account as Address,
           ],
         });
diff --git a/src/hooks/useLeverageTransaction.ts b/src/hooks/useLeverageTransaction.ts
index 063d2f6b..331a9373 100644
--- a/src/hooks/useLeverageTransaction.ts
+++ b/src/hooks/useLeverageTransaction.ts
@@ -1,40 +1,26 @@
 import { useCallback, useMemo } from 'react';
-import { type Address, encodeAbiParameters, encodeFunctionData, isAddress, isAddressEqual, keccak256, maxUint256, zeroHash } from 'viem';
+import type { Address } from 'viem';
+import type { VeloraPriceRoute } from '@/features/swap/api/velora';
 import { useConnection } from 'wagmi';
-import morphoBundlerAbi from '@/abis/bundlerV2';
-import { bundlerV3Abi } from '@/abis/bundlerV3';
-import morphoAbi from '@/abis/morpho';
-import { morphoGeneralAdapterV1Abi } from '@/abis/morphoGeneralAdapterV1';
-import { paraswapAdapterAbi } from '@/abis/paraswapAdapter';
-import permit2Abi from '@/abis/permit2';
 import { getLeverageFee } from '@/config/fees';
-import { LEVERAGE_FEE_RECIPIENT, resolveErc4626RouteBundler } from '@/config/leverage';
-import { buildVeloraTransactionPayload, isVeloraRateChangedError, type VeloraPriceRoute } from '@/features/swap/api/velora';
+import { resolveErc4626RouteBundler } from '@/config/leverage';
 import { useERC20Approval } from '@/hooks/useERC20Approval';
 import { useBundlerAuthorizationStep } from '@/hooks/useBundlerAuthorizationStep';
 import { usePermit2 } from '@/hooks/usePermit2';
 import { useStyledToast } from '@/hooks/useStyledToast';
 import { useTransactionWithToast } from '@/hooks/useTransactionWithToast';
 import { useTransactionTracking } from '@/hooks/useTransactionTracking';
+import { leverageWithErc4626Deposit } from '@/hooks/leverage/leverageWithErc4626Deposit';
+import { leverageWithSwap } from '@/hooks/leverage/leverageWithSwap';
+import { buildLeverageMarketParams, type LeverageStepType } from '@/hooks/leverage/transaction-shared';
+import type { LeverageRoute } from '@/hooks/leverage/types';
 import { useUserMarketsCache } from '@/stores/useUserMarketsCache';
 import { useAppSettings } from '@/stores/useAppSettings';
 import { formatBalance } from '@/utils/balance';
-import { getMorphoAddress, MONARCH_TX_IDENTIFIER } from '@/utils/morpho';
-import { PERMIT2_ADDRESS } from '@/utils/permit2';
 import { toUserFacingTransactionErrorMessage } from '@/utils/transaction-errors';
 import type { Market } from '@/utils/types';
-import { type Bundler3Call, encodeBundler3Calls, getParaswapSellOffsets, readCalldataUint256 } from './leverage/bundler3';
-import { computeBorrowSharesWithBuffer, withSlippageFloor } from './leverage/math';
-import type { LeverageRoute } from './leverage/types';
-import { isVeloraBypassablePrecheckError } from './leverage/velora-precheck';
-
-export type LeverageStepType =
-  | 'approve_permit2'
-  | 'authorize_bundler_sig'
-  | 'sign_permit'
-  | 'authorize_bundler_tx'
-  | 'approve_token'
-  | 'execute';
+
+export type { LeverageStepType } from '@/hooks/leverage/transaction-shared';
 
 type UseLeverageTransactionProps = {
   market: Market;
@@ -81,12 +67,14 @@ export function useLeverageTransaction({
     if (route?.kind === 'swap') {
       return route.bundler3Address;
     }
+
     return resolveErc4626RouteBundler(market.morphoBlue.chain.id, market.uniqueKey);
   }, [route, market.uniqueKey, market.morphoBlue.chain.id]);
   const authorizationTarget = useMemo<Address>(() => {
     if (route?.kind === 'swap') {
       return route.generalAdapterAddress;
     }
+
     return bundlerAddress;
   }, [route, bundlerAddress]);
 
@@ -147,6 +135,16 @@ export function useLeverageTransaction({
       if (onSuccess) void onSuccess();
     },
   });
+  const trackingMetadata = useMemo(
+    () => ({
+      title: 'Leverage',
+      description: `${market.collateralAsset.symbol} leveraged using ${market.loanAsset.symbol} debt`,
+      tokenSymbol: inputTokenSymbol,
+      amount: collateralAmount,
+      marketId: market.uniqueKey,
+    }),
+    [market.collateralAsset.symbol, market.loanAsset.symbol, inputTokenSymbol, collateralAmount, market.uniqueKey],
+  );
 
   const getStepsForFlow = useCallback(
     (isPermit2: boolean, isSwap: boolean) => {
@@ -261,6 +259,7 @@ export function useLeverageTransaction({
       toast.info('Leverage unavailable', 'Collateral price unavailable for fee calculation.');
       return;
     }
+
     const leverageFeeAmount = getLeverageFee({
       amount: totalAddedCollateral,
       assetPriceUsd: collateralAssetPriceUsd,
@@ -272,485 +271,64 @@ export function useLeverageTransaction({
     }
 
     try {
-      const txs: `0x${string}`[] = [];
-      let swapRouteAuthorizationCall: Bundler3Call | null = null;
-      let swapRoutePermit2Call: Bundler3Call | null = null;
-
-      if (usePermit2ForRoute) {
-        if (!permit2Authorized) {
-          tracking.update('approve_permit2');
-          await authorizePermit2();
-          await new Promise((resolve) => setTimeout(resolve, 800));
-        }
-
-        if (!isBundlerAuthorized) {
-          tracking.update('authorize_bundler_sig');
-        }
-        const { authorized, authorizationTxData, authorizationSignatureData } = await ensureBundlerAuthorization({ mode: 'signature' });
-        if (!authorized) {
-          throw new Error('Failed to authorize Bundler via signature.');
-        }
-        if (isBundlerAuthorized && authorizationTxData) {
-          throw new Error('Authorization state changed. Please retry leverage.');
-        }
-        if (authorizationTxData) {
-          if (route.kind === 'swap') {
-            if (!authorizationSignatureData) {
-              throw new Error('Missing Morpho authorization signature payload for swap-backed leverage.');
-            }
-            swapRouteAuthorizationCall = {
-              to: getMorphoAddress(market.morphoBlue.chain.id) as Address,
-              data: encodeFunctionData({
-                abi: morphoAbi,
-                functionName: 'setAuthorizationWithSig',
-                args: [authorizationSignatureData.authorization, authorizationSignatureData.signature],
-              }),
-              value: 0n,
-              skipRevert: false,
-              callbackHash: zeroHash,
-            };
-          } else {
-            txs.push(authorizationTxData);
-          }
-          await new Promise((resolve) => setTimeout(resolve, 800));
-        }
-
-        tracking.update('sign_permit');
-        const { sigs, permitSingle } = await signForBundlers();
-        if (route.kind === 'swap') {
-          swapRoutePermit2Call = {
-            to: PERMIT2_ADDRESS,
-            data: encodeFunctionData({
-              abi: permit2Abi,
-              functionName: 'permit',
-              args: [account as Address, permitSingle, sigs],
-            }),
-            value: 0n,
-            skipRevert: false,
-            callbackHash: zeroHash,
-          };
-        } else {
-          txs.push(
-            encodeFunctionData({
-              abi: morphoBundlerAbi,
-              functionName: 'approve2',
-              args: [permitSingle, sigs, false],
-            }),
-          );
-        }
-      } else {
-        if (!isBundlerAuthorized) {
-          tracking.update('authorize_bundler_tx');
-          const { authorized } = await ensureBundlerAuthorization({ mode: 'transaction' });
-          if (!authorized) {
-            throw new Error('Failed to authorize Bundler via transaction.');
-          }
-        }
-
-        if (!isApproved) {
-          tracking.update('approve_token');
-          await approve();
-          await new Promise((resolve) => setTimeout(resolve, 900));
-        }
-      }
-
-      const marketParams = {
-        loanToken: market.loanAsset.address as Address,
-        collateralToken: market.collateralAsset.address as Address,
-        oracle: market.oracleAddress as Address,
-        irm: market.irmAddress as Address,
-        lltv: BigInt(market.lltv),
-      };
+      const marketParams = buildLeverageMarketParams(market);
 
       if (route.kind === 'swap') {
-        if (!Number.isFinite(slippageBps) || slippageBps <= 0) {
-          throw new Error('Invalid slippage tolerance. Please set a positive slippage value.');
-        }
         if (!swapPriceRoute) {
           throw new Error('Missing Velora swap quote for leverage.');
         }
-        const preFlashCollateralFee =
-          !isLoanAssetInput && inputTokenAmountForTransfer > 0n
-            ? leverageFeeAmount < inputTokenAmountForTransfer
-              ? leverageFeeAmount
-              : inputTokenAmountForTransfer
-            : 0n;
-        const callbackCollateralFee = leverageFeeAmount - preFlashCollateralFee;
-        const preFlashCollateralSupplyAmount = inputTokenAmountForTransfer - preFlashCollateralFee;
-        const swapExecutionAddress = route.paraswapAdapterAddress;
-        // WHY: when starting from loan on a swap route, we combine the user's loan input
-        // with the flash-loaned loan and sell them together before supplying collateral.
-        const totalLoanSellAmount = isLoanAssetInput ? inputTokenAmountForTransfer + flashLoanAmount : flashLoanAmount;
-        if (totalLoanSellAmount <= 0n) {
-          throw new Error('Invalid total sell amount for swap-backed leverage.');
-        }
-
-        const activePriceRoute = swapPriceRoute;
-        const swapTxPayload = await (async () => {
-          const buildPayload = async (ignoreChecks: boolean) =>
-            buildVeloraTransactionPayload({
-              srcToken: market.loanAsset.address,
-              srcDecimals: market.loanAsset.decimals,
-              destToken: market.collateralAsset.address,
-              destDecimals: market.collateralAsset.decimals,
-              srcAmount: totalLoanSellAmount,
-              network: market.morphoBlue.chain.id,
-              userAddress: swapExecutionAddress,
-              priceRoute: activePriceRoute,
-              slippageBps,
-              ignoreChecks,
-            });
-
-          try {
-            return await buildPayload(false);
-          } catch (buildError: unknown) {
-            if (isVeloraRateChangedError(buildError)) {
-              throw new Error('Leverage quote changed. Please review the updated preview and try again.');
-            }
-            if (
-              !isVeloraBypassablePrecheckError({
-                error: buildError,
-                sourceTokenAddress: market.loanAsset.address,
-                sourceTokenSymbol: market.loanAsset.symbol,
-              })
-            ) {
-              throw buildError;
-            }
-
-            try {
-              return await buildPayload(true);
-            } catch (fallbackBuildError: unknown) {
-              if (isVeloraRateChangedError(fallbackBuildError)) {
-                throw new Error('Leverage quote changed. Please review the updated preview and try again.');
-              }
-              throw fallbackBuildError;
-            }
-          }
-        })();
-
-        const trustedVeloraTargets = [activePriceRoute.contractAddress, activePriceRoute.tokenTransferProxy].filter(
-          (candidate): candidate is Address => typeof candidate === 'string' && isAddress(candidate),
-        );
-        if (trustedVeloraTargets.length === 0 || !trustedVeloraTargets.some((target) => isAddressEqual(swapTxPayload.to, target))) {
-          throw new Error('Leverage quote changed. Please review the updated preview and try again.');
-        }
-
-        const expectedCollateralOut = isLoanAssetInput ? totalAddedCollateral : flashCollateralAmount;
-        if (expectedCollateralOut <= 0n) {
-          throw new Error('Velora returned zero collateral output for leverage swap.');
-        }
-
-        const sellOffsets = getParaswapSellOffsets(swapTxPayload.data);
-        const quotedSellAmount = BigInt(activePriceRoute.srcAmount);
-        const calldataSellAmount = readCalldataUint256(swapTxPayload.data, sellOffsets.exactAmount);
-        const calldataMinCollateralOut = readCalldataUint256(swapTxPayload.data, sellOffsets.limitAmount);
-        if (
-          quotedSellAmount !== totalLoanSellAmount ||
-          calldataSellAmount !== totalLoanSellAmount ||
-          calldataMinCollateralOut !== expectedCollateralOut
-        ) {
-          throw new Error('Leverage quote changed. Please review the updated preview and try again.');
-        }
-
-        const callbackBundle: Bundler3Call[] = [
-          {
-            to: route.generalAdapterAddress,
-            data: encodeFunctionData({
-              abi: morphoGeneralAdapterV1Abi,
-              functionName: 'erc20Transfer',
-              args: [market.loanAsset.address as Address, route.paraswapAdapterAddress, totalLoanSellAmount],
-            }),
-            value: 0n,
-            skipRevert: false,
-            callbackHash: zeroHash,
-          },
-          {
-            to: route.paraswapAdapterAddress,
-            data: encodeFunctionData({
-              abi: paraswapAdapterAbi,
-              functionName: 'sell',
-              args: [
-                swapTxPayload.to,
-                swapTxPayload.data,
-                market.loanAsset.address as Address,
-                market.collateralAsset.address as Address,
-                false,
-                sellOffsets,
-                route.generalAdapterAddress,
-              ],
-            }),
-            value: 0n,
-            skipRevert: false,
-            callbackHash: zeroHash,
-          },
-        ];
-
-        if (callbackCollateralFee > 0n) {
-          callbackBundle.push({
-            to: route.generalAdapterAddress,
-            data: encodeFunctionData({
-              abi: morphoGeneralAdapterV1Abi,
-              functionName: 'erc20Transfer',
-              args: [market.collateralAsset.address as Address, LEVERAGE_FEE_RECIPIENT, callbackCollateralFee],
-            }),
-            value: 0n,
-            skipRevert: false,
-            callbackHash: zeroHash,
-          });
-        }
 
-        callbackBundle.push(
-          {
-            to: route.generalAdapterAddress,
-            data: encodeFunctionData({
-              abi: morphoGeneralAdapterV1Abi,
-              functionName: 'morphoSupplyCollateral',
-              args: [marketParams, maxUint256, account as Address, '0x'],
-            }),
-            value: 0n,
-            skipRevert: false,
-            callbackHash: zeroHash,
-          },
-          {
-            to: route.generalAdapterAddress,
-            data: encodeFunctionData({
-              abi: morphoGeneralAdapterV1Abi,
-              functionName: 'morphoBorrow',
-              args: [marketParams, flashLoanAmount, 0n, 0n, route.generalAdapterAddress],
-            }),
-            value: 0n,
-            skipRevert: false,
-            callbackHash: zeroHash,
-          },
-        );
-        const callbackBundleData = encodeBundler3Calls(callbackBundle);
-
-        const bundleCalls: Bundler3Call[] = [];
-        if (swapRouteAuthorizationCall) {
-          bundleCalls.push(swapRouteAuthorizationCall);
-        }
-        if (swapRoutePermit2Call) {
-          bundleCalls.push(swapRoutePermit2Call);
-        }
-
-        if (inputTokenAmountForTransfer > 0n) {
-          bundleCalls.push({
-            to: route.generalAdapterAddress,
-            data: encodeFunctionData({
-              abi: morphoGeneralAdapterV1Abi,
-              functionName: usePermit2ForRoute ? 'permit2TransferFrom' : 'erc20TransferFrom',
-              args: [inputTokenAddress, route.generalAdapterAddress, inputTokenAmountForTransfer],
-            }),
-            value: 0n,
-            skipRevert: false,
-            callbackHash: zeroHash,
-          });
-          if (!isLoanAssetInput) {
-            if (preFlashCollateralFee > 0n) {
-              bundleCalls.push({
-                to: route.generalAdapterAddress,
-                data: encodeFunctionData({
-                  abi: morphoGeneralAdapterV1Abi,
-                  functionName: 'erc20Transfer',
-                  args: [market.collateralAsset.address as Address, LEVERAGE_FEE_RECIPIENT, preFlashCollateralFee],
-                }),
-                value: 0n,
-                skipRevert: false,
-                callbackHash: zeroHash,
-              });
-            }
-            if (preFlashCollateralSupplyAmount > 0n) {
-              bundleCalls.push({
-                to: route.generalAdapterAddress,
-                data: encodeFunctionData({
-                  abi: morphoGeneralAdapterV1Abi,
-                  functionName: 'morphoSupplyCollateral',
-                  args: [marketParams, preFlashCollateralSupplyAmount, account as Address, '0x'],
-                }),
-                value: 0n,
-                skipRevert: false,
-                callbackHash: zeroHash,
-              });
-            }
-          }
-        }
-
-        bundleCalls.push({
-          to: route.generalAdapterAddress,
-          data: encodeFunctionData({
-            abi: morphoGeneralAdapterV1Abi,
-            functionName: 'morphoFlashLoan',
-            args: [market.loanAsset.address as Address, flashLoanAmount, callbackBundleData],
-          }),
-          value: 0n,
-          skipRevert: false,
-          callbackHash: keccak256(callbackBundleData),
-        });
-        // Safety net: sweep any residual loan/collateral balances from adapters to the user.
-        bundleCalls.push(
-          {
-            to: route.generalAdapterAddress,
-            data: encodeFunctionData({
-              abi: morphoGeneralAdapterV1Abi,
-              functionName: 'erc20Transfer',
-              args: [market.loanAsset.address as Address, account as Address, maxUint256],
-            }),
-            value: 0n,
-            skipRevert: false,
-            callbackHash: zeroHash,
-          },
-          {
-            to: route.generalAdapterAddress,
-            data: encodeFunctionData({
-              abi: morphoGeneralAdapterV1Abi,
-              functionName: 'erc20Transfer',
-              args: [market.collateralAsset.address as Address, account as Address, maxUint256],
-            }),
-            value: 0n,
-            skipRevert: false,
-            callbackHash: zeroHash,
-          },
-          {
-            to: route.paraswapAdapterAddress,
-            data: encodeFunctionData({
-              abi: paraswapAdapterAbi,
-              functionName: 'erc20Transfer',
-              args: [market.loanAsset.address as Address, account as Address, maxUint256],
-            }),
-            value: 0n,
-            skipRevert: false,
-            callbackHash: zeroHash,
-          },
-          {
-            to: route.paraswapAdapterAddress,
-            data: encodeFunctionData({
-              abi: paraswapAdapterAbi,
-              functionName: 'erc20Transfer',
-              args: [market.collateralAsset.address as Address, account as Address, maxUint256],
-            }),
-            value: 0n,
-            skipRevert: false,
-            callbackHash: zeroHash,
-          },
-        );
-
-        tracking.update('execute');
-        await new Promise((resolve) => setTimeout(resolve, 800));
-
-        await sendTransactionAsync({
-          account,
-          to: bundlerAddress,
-          data: (encodeFunctionData({
-            abi: bundlerV3Abi,
-            functionName: 'multicall',
-            args: [bundleCalls],
-          }) + MONARCH_TX_IDENTIFIER) as `0x${string}`,
-          value: 0n,
+        await leverageWithSwap({
+          account: account as Address,
+          bundlerAddress,
+          market,
+          marketParams,
+          route,
+          inputTokenAddress,
+          inputTokenAmountForTransfer,
+          isLoanAssetInput,
+          flashLoanAmount,
+          flashCollateralAmount,
+          totalAddedCollateral,
+          leverageFeeAmount,
+          swapPriceRoute,
+          slippageBps,
+          usePermit2: usePermit2ForRoute,
+          permit2Authorized,
+          isBundlerAuthorized,
+          authorizePermit2,
+          ensureBundlerAuthorization,
+          signForBundlers,
+          isApproved,
+          approve,
+          updateStep: tracking.update,
+          sendTransactionAsync,
         });
       } else {
-        const maxBorrowShares = computeBorrowSharesWithBuffer({
-          borrowAssets: flashLoanAmount,
-          totalBorrowAssets: BigInt(market.state.borrowAssets),
-          totalBorrowShares: BigInt(market.state.borrowShares),
-        });
-
-        if (inputTokenAmountForTransfer > 0n) {
-          txs.push(
-            encodeFunctionData({
-              abi: morphoBundlerAbi,
-              functionName: usePermit2ForRoute ? 'transferFrom2' : 'erc20TransferFrom',
-              args: [inputTokenAddress, inputTokenAmountForTransfer],
-            }),
-          );
-        }
-
-        if (isLoanAssetInput) {
-          // WHY: this lets users start with loan-token underlying for ERC4626 markets.
-          // We mint shares first so all leverage math and downstream Morpho collateral is in share units.
-          txs.push(
-            encodeFunctionData({
-              abi: morphoBundlerAbi,
-              functionName: 'erc4626Deposit',
-              args: [
-                route.collateralVault,
-                collateralAmount,
-                withSlippageFloor(collateralAmountInCollateralToken),
-                bundlerAddress as Address,
-              ],
-            }),
-          );
-        }
-
-        const callbackTxs: `0x${string}`[] = [
-          encodeFunctionData({
-            abi: morphoBundlerAbi,
-            functionName: 'erc4626Deposit',
-            args: [route.collateralVault, flashLoanAmount, withSlippageFloor(flashCollateralAmount), bundlerAddress as Address],
-          }),
-        ];
-
-        if (leverageFeeAmount > 0n) {
-          callbackTxs.push(
-            encodeFunctionData({
-              abi: morphoBundlerAbi,
-              functionName: 'erc20Transfer',
-              args: [market.collateralAsset.address as Address, LEVERAGE_FEE_RECIPIENT, leverageFeeAmount],
-            }),
-          );
-        }
-
-        callbackTxs.push(
-          encodeFunctionData({
-            abi: morphoBundlerAbi,
-            functionName: 'morphoSupplyCollateral',
-            args: [marketParams, maxUint256, account as Address, '0x'],
-          }),
-        );
-
-        callbackTxs.push(
-          encodeFunctionData({
-            abi: morphoBundlerAbi,
-            functionName: 'morphoBorrow',
-            args: [marketParams, flashLoanAmount, 0n, maxBorrowShares, bundlerAddress as Address],
-          }),
-        );
-
-        const flashLoanCallbackData = encodeAbiParameters([{ type: 'bytes[]' }], [callbackTxs]);
-        txs.push(
-          encodeFunctionData({
-            abi: morphoBundlerAbi,
-            functionName: 'morphoFlashLoan',
-            args: [market.loanAsset.address as Address, flashLoanAmount, flashLoanCallbackData],
-          }),
-        );
-        // Safety net: sweep any residual loan/collateral balances from bundler to the user.
-        txs.push(
-          encodeFunctionData({
-            abi: morphoBundlerAbi,
-            functionName: 'erc20Transfer',
-            args: [market.loanAsset.address as Address, account as Address, maxUint256],
-          }),
-        );
-        txs.push(
-          encodeFunctionData({
-            abi: morphoBundlerAbi,
-            functionName: 'erc20Transfer',
-            args: [market.collateralAsset.address as Address, account as Address, maxUint256],
-          }),
-        );
-
-        tracking.update('execute');
-        await new Promise((resolve) => setTimeout(resolve, 800));
-
-        await sendTransactionAsync({
-          account,
-          to: bundlerAddress,
-          data: (encodeFunctionData({
-            abi: morphoBundlerAbi,
-            functionName: 'multicall',
-            args: [txs],
-          }) + MONARCH_TX_IDENTIFIER) as `0x${string}`,
-          value: 0n,
+        await leverageWithErc4626Deposit({
+          account: account as Address,
+          bundlerAddress,
+          market,
+          marketParams,
+          route,
+          collateralAmount,
+          collateralAmountInCollateralToken,
+          inputTokenAddress,
+          inputTokenAmountForTransfer,
+          isLoanAssetInput,
+          flashCollateralAmount,
+          flashLoanAmount,
+          leverageFeeAmount,
+          usePermit2: usePermit2ForRoute,
+          permit2Authorized,
+          isBundlerAuthorized,
+          authorizePermit2,
+          ensureBundlerAuthorization,
+          signForBundlers,
+          isApproved,
+          approve,
+          updateStep: tracking.update,
+          sendTransactionAsync,
         });
       }
 
@@ -772,12 +350,12 @@ export function useLeverageTransaction({
     }
   }, [
     account,
-    market,
     route,
+    market,
     collateralAmount,
     collateralAmountInCollateralToken,
-    inputTokenAmountForTransfer,
     inputTokenAddress,
+    inputTokenAmountForTransfer,
     isLoanAssetInput,
     flashCollateralAmount,
     flashLoanAmount,
@@ -800,60 +378,58 @@ export function useLeverageTransaction({
     toast,
   ]);
 
-  const approveAndLeverage = useCallback(async () => {
-    if (!account) {
-      toast.info('No account connected', 'Please connect your wallet.');
-      return;
-    }
-
-    try {
-      const initialStep: LeverageStepType = usePermit2ForRoute
-        ? permit2Authorized
-          ? isBundlerAuthorized
-            ? 'sign_permit'
-            : 'authorize_bundler_sig'
-          : 'approve_permit2'
-        : isBundlerAuthorized
-          ? isApproved
-            ? 'execute'
-            : 'approve_token'
-          : 'authorize_bundler_tx';
-      tracking.start(
-        getStepsForFlow(usePermit2ForRoute, isSwapRoute),
-        {
-          title: 'Leverage',
-          description: `${market.collateralAsset.symbol} leveraged using ${market.loanAsset.symbol} debt`,
-          tokenSymbol: inputTokenSymbol,
-          amount: collateralAmount,
-          marketId: market.uniqueKey,
-        },
-        initialStep,
-      );
+  const runLeverageFlow = useCallback(
+    async ({
+      initialStep,
+      usePermit2Flow,
+      errorTitle,
+      logLabel,
+    }: {
+      initialStep: LeverageStepType;
+      usePermit2Flow: boolean;
+      errorTitle: string;
+      logLabel: string;
+    }) => {
+      if (!account) {
+        toast.info('No account connected', 'Please connect your wallet.');
+        return;
+      }
 
-      await executeLeverage();
-    } catch (error: unknown) {
-      console.error('Error in approveAndLeverage:', error);
-      tracking.fail();
-      const userFacingMessage = toUserFacingTransactionErrorMessage(error, 'Failed to process leverage transaction');
-      if (userFacingMessage !== 'User rejected transaction.') {
-        toast.error('Error', userFacingMessage);
+      try {
+        tracking.start(getStepsForFlow(usePermit2Flow, isSwapRoute), trackingMetadata, initialStep);
+        await executeLeverage();
+      } catch (error: unknown) {
+        console.error(`Error in ${logLabel}:`, error);
+        tracking.fail();
+        const userFacingMessage = toUserFacingTransactionErrorMessage(error, 'Failed to process leverage transaction');
+        if (userFacingMessage !== 'User rejected transaction.') {
+          toast.error(errorTitle, userFacingMessage);
+        }
       }
-    }
-  }, [
-    account,
-    usePermit2ForRoute,
-    permit2Authorized,
-    isBundlerAuthorized,
-    isApproved,
-    tracking,
-    getStepsForFlow,
-    isSwapRoute,
-    market,
-    inputTokenSymbol,
-    collateralAmount,
-    executeLeverage,
-    toast,
-  ]);
+    },
+    [account, tracking, getStepsForFlow, isSwapRoute, trackingMetadata, executeLeverage, toast],
+  );
+
+  const approveAndLeverage = useCallback(async () => {
+    const initialStep: LeverageStepType = usePermit2ForRoute
+      ? permit2Authorized
+        ? isBundlerAuthorized
+          ? 'sign_permit'
+          : 'authorize_bundler_sig'
+        : 'approve_permit2'
+      : isBundlerAuthorized
+        ? isApproved
+          ? 'execute'
+          : 'approve_token'
+        : 'authorize_bundler_tx';
+
+    await runLeverageFlow({
+      initialStep,
+      usePermit2Flow: usePermit2ForRoute,
+      errorTitle: 'Error',
+      logLabel: 'approveAndLeverage',
+    });
+  }, [usePermit2ForRoute, permit2Authorized, isBundlerAuthorized, isApproved, runLeverageFlow]);
 
   const signAndLeverage = useCallback(async () => {
     if (!usePermit2ForRoute) {
@@ -861,53 +437,19 @@ export function useLeverageTransaction({
       return;
     }
 
-    if (!account) {
-      toast.info('No account connected', 'Please connect your wallet.');
-      return;
-    }
-
-    try {
-      const initialStep: LeverageStepType = permit2Authorized
-        ? isBundlerAuthorized
-          ? 'sign_permit'
-          : 'authorize_bundler_sig'
-        : 'approve_permit2';
-
-      tracking.start(
-        getStepsForFlow(true, isSwapRoute),
-        {
-          title: 'Leverage',
-          description: `${market.collateralAsset.symbol} leveraged using ${market.loanAsset.symbol} debt`,
-          tokenSymbol: inputTokenSymbol,
-          amount: collateralAmount,
-          marketId: market.uniqueKey,
-        },
-        initialStep,
-      );
-
-      await executeLeverage();
-    } catch (error: unknown) {
-      console.error('Error in signAndLeverage:', error);
-      tracking.fail();
-      const userFacingMessage = toUserFacingTransactionErrorMessage(error, 'Failed to process leverage transaction');
-      if (userFacingMessage !== 'User rejected transaction.') {
-        toast.error('Transaction Error', userFacingMessage);
-      }
-    }
-  }, [
-    usePermit2ForRoute,
-    approveAndLeverage,
-    account,
-    tracking,
-    getStepsForFlow,
-    permit2Authorized,
-    isBundlerAuthorized,
-    market,
-    inputTokenSymbol,
-    collateralAmount,
-    executeLeverage,
-    toast,
-  ]);
+    const initialStep: LeverageStepType = permit2Authorized
+      ? isBundlerAuthorized
+        ? 'sign_permit'
+        : 'authorize_bundler_sig'
+      : 'approve_permit2';
+
+    await runLeverageFlow({
+      initialStep,
+      usePermit2Flow: true,
+      errorTitle: 'Transaction Error',
+      logLabel: 'signAndLeverage',
+    });
+  }, [usePermit2ForRoute, approveAndLeverage, permit2Authorized, isBundlerAuthorized, runLeverageFlow]);
 
   const isLoading =
     leveragePending || (usePermit2ForRoute && isLoadingPermit2) || !isAuthorizationReadyForRoute || isApproving || isAuthorizingBundler;
diff --git a/src/hooks/useMultiMarketSupply.ts b/src/hooks/useMultiMarketSupply.ts
index ee11335f..d4b39886 100644
--- a/src/hooks/useMultiMarketSupply.ts
+++ b/src/hooks/useMultiMarketSupply.ts
@@ -7,6 +7,7 @@ import { useTransactionWithToast } from '@/hooks/useTransactionWithToast';
 import { useTransactionTracking } from '@/hooks/useTransactionTracking';
 import type { NetworkToken } from '@/types/token';
 import { formatBalance } from '@/utils/balance';
+import { MIN_SHARES_SLIPPAGE_AMOUNT } from '@/hooks/leverage/math';
 import { getBundlerV2, MONARCH_TX_IDENTIFIER } from '@/utils/morpho';
 import type { Market } from '@/utils/types';
 import { GAS_COSTS, GAS_MULTIPLIER_NUMERATOR, GAS_MULTIPLIER_DENOMINATOR } from '@/features/markets/components/constants';
@@ -135,6 +136,7 @@ export function useMultiMarketSupply(
 
       // Add supply transactions for each market
       for (const supply of supplies) {
+        // Asset-based supply keeps the asset amount exact and only needs a minimum-share floor.
         const morphoSupplyTx = encodeFunctionData({
           abi: morphoBundlerAbi,
           functionName: 'morphoSupply',
@@ -148,7 +150,7 @@ export function useMultiMarketSupply(
             },
             supply.amount,
             BigInt(0),
-            BigInt(1), // minShares
+            MIN_SHARES_SLIPPAGE_AMOUNT,
             account as `0x${string}`,
             '0x', // callback
           ],
diff --git a/src/hooks/useSupplyMarket.ts b/src/hooks/useSupplyMarket.ts
index 11c78ef5..b948f00f 100644
--- a/src/hooks/useSupplyMarket.ts
+++ b/src/hooks/useSupplyMarket.ts
@@ -10,6 +10,7 @@ import { useTransactionWithToast } from '@/hooks/useTransactionWithToast';
 import { useUserMarketsCache } from '@/stores/useUserMarketsCache';
 import { useTransactionTracking } from '@/hooks/useTransactionTracking';
 import { formatBalance } from '@/utils/balance';
+import { MIN_SHARES_SLIPPAGE_AMOUNT } from '@/hooks/leverage/math';
 import { getBundlerV2, MONARCH_TX_IDENTIFIER } from '@/utils/morpho';
 import type { Market } from '@/utils/types';
 import { GAS_COSTS, GAS_MULTIPLIER_NUMERATOR, GAS_MULTIPLIER_DENOMINATOR } from '@/features/markets/components/constants';
@@ -219,7 +220,8 @@ export function useSupplyMarket(market: Market, onSuccess?: () => void): UseSupp
 
       update('supplying');
 
-      const minShares = BigInt(1);
+      // Asset-based supply keeps the asset amount exact and only needs a minimum-share floor.
+      const minSharesSlippageAmount = MIN_SHARES_SLIPPAGE_AMOUNT;
       const morphoSupplyTx = encodeFunctionData({
         abi: morphoBundlerAbi,
         functionName: 'morphoSupply',
@@ -233,7 +235,7 @@ export function useSupplyMarket(market: Market, onSuccess?: () => void): UseSupp
           },
           supplyAmount,
           BigInt(0),
-          minShares,
+          minSharesSlippageAmount,
           account as `0x${string}`,
           '0x', // callback
         ],
diff --git a/src/modals/borrow/components/withdraw-collateral-and-repay.tsx b/src/modals/borrow/components/withdraw-collateral-and-repay.tsx
index 16c142cb..ca1518a8 100644
--- a/src/modals/borrow/components/withdraw-collateral-and-repay.tsx
+++ b/src/modals/borrow/components/withdraw-collateral-and-repay.tsx
@@ -1,4 +1,4 @@
-import { useMemo, useState, useEffect, useCallback } from 'react';
+import { useMemo, useState, useCallback } from 'react';
 import { LTVWarning } from '@/components/shared/ltv-warning';
 import { IconSwitch } from '@/components/ui/icon-switch';
 import Input from '@/components/Input/Input';
diff --git a/src/modals/leverage/components/add-collateral-and-leverage.tsx b/src/modals/leverage/components/add-collateral-and-leverage.tsx
index 93a600c2..0a2100c2 100644
--- a/src/modals/leverage/components/add-collateral-and-leverage.tsx
+++ b/src/modals/leverage/components/add-collateral-and-leverage.tsx
@@ -682,31 +682,27 @@ export function AddCollateralAndLeverage({
               </div>
               <div className="relative min-w-0">
                 {useTargetLtvInput ? (
-                  <>
-                    <Input
-                      decimals={2}
-                      setValue={(nextTargetLtvBps) => {
-                        const clampedTargetLtvBps = clampTargetLtvBps(nextTargetLtvBps, maxTargetLtvBps);
-                        setTargetLtvIntentBps(clampedTargetLtvBps);
-                        setTargetMultiplierBps(multiplierBpsFromTargetLtv(clampedTargetLtvBps, maxMultiplierBps));
-                      }}
-                      value={targetLtvIntentBps}
-                      inputClassName="h-10 rounded bg-hovered px-3 py-2 pr-10 text-base font-medium tabular-nums"
-                      endAdornment={<span className="text-xs text-secondary">%</span>}
-                      debounceSetValueMs={TARGET_INPUT_DEBOUNCE_MS}
-                    />
-                  </>
+                  <Input
+                    decimals={2}
+                    setValue={(nextTargetLtvBps) => {
+                      const clampedTargetLtvBps = clampTargetLtvBps(nextTargetLtvBps, maxTargetLtvBps);
+                      setTargetLtvIntentBps(clampedTargetLtvBps);
+                      setTargetMultiplierBps(multiplierBpsFromTargetLtv(clampedTargetLtvBps, maxMultiplierBps));
+                    }}
+                    value={targetLtvIntentBps}
+                    inputClassName="h-10 rounded bg-hovered px-3 py-2 pr-10 text-base font-medium tabular-nums"
+                    endAdornment={<span className="text-xs text-secondary">%</span>}
+                    debounceSetValueMs={TARGET_INPUT_DEBOUNCE_MS}
+                  />
                 ) : (
-                  <>
-                    <Input
-                      decimals={4}
-                      setValue={syncInputFieldsFromMultiplier}
-                      value={multiplierBps}
-                      inputClassName="h-10 rounded bg-hovered px-3 py-2 pr-10 text-base font-medium tabular-nums"
-                      endAdornment={<span className="text-xs text-secondary">x</span>}
-                      debounceSetValueMs={TARGET_INPUT_DEBOUNCE_MS}
-                    />
-                  </>
+                  <Input
+                    decimals={4}
+                    setValue={syncInputFieldsFromMultiplier}
+                    value={multiplierBps}
+                    inputClassName="h-10 rounded bg-hovered px-3 py-2 pr-10 text-base font-medium tabular-nums"
+                    endAdornment={<span className="text-xs text-secondary">x</span>}
+                    debounceSetValueMs={TARGET_INPUT_DEBOUNCE_MS}
+                  />
                 )}
               </div>
             </div>
diff --git a/src/modals/leverage/components/remove-collateral-and-deleverage.tsx b/src/modals/leverage/components/remove-collateral-and-deleverage.tsx
index 6658cd39..346d4323 100644
--- a/src/modals/leverage/components/remove-collateral-and-deleverage.tsx
+++ b/src/modals/leverage/components/remove-collateral-and-deleverage.tsx
@@ -13,11 +13,7 @@ import { useDeleverageQuote } from '@/hooks/useDeleverageQuote';
 import { useDeleverageTransaction } from '@/hooks/useDeleverageTransaction';
 import type { Market, MarketPosition } from '@/utils/types';
 import type { LeverageRoute } from '@/hooks/leverage/types';
-import {
-  computeLtv,
-  formatLtvPercent,
-  getLTVColor,
-} from '@/modals/borrow/components/helpers';
+import { computeLtv, formatLtvPercent, getLTVColor } from '@/modals/borrow/components/helpers';
 import { BorrowPositionRiskCard } from '@/modals/borrow/components/borrow-position-risk-card';
 
 type RemoveCollateralAndDeleverageProps = {

From 62e296a87af5d16b119d368b86b952d2f3332ef6 Mon Sep 17 00:00:00 2001
From: antoncoding <antonassocareer@gmail.com>
Date: Sun, 8 Mar 2026 17:10:10 +0800
Subject: [PATCH 2/5] refactor: deleverage

---
 .../deleverage/deleverageWithErc4626Redeem.ts | 158 ++++++
 src/hooks/deleverage/deleverageWithSwap.ts    | 242 ++++++++
 src/hooks/deleverage/transaction-shared.ts    |  39 ++
 src/hooks/leverage/bundler3.ts                |  41 +-
 .../leverage/leverageWithErc4626Deposit.ts    |  16 +-
 src/hooks/leverage/leverageWithSwap.ts        | 187 ++----
 src/hooks/leverage/transaction-shared.ts      |  12 +-
 src/hooks/leverage/velora-transaction.ts      |  91 +++
 src/hooks/useDeleverageTransaction.ts         | 537 ++++--------------
 src/hooks/useLeverageTransaction.ts           |   4 +-
 10 files changed, 751 insertions(+), 576 deletions(-)
 create mode 100644 src/hooks/deleverage/deleverageWithErc4626Redeem.ts
 create mode 100644 src/hooks/deleverage/deleverageWithSwap.ts
 create mode 100644 src/hooks/deleverage/transaction-shared.ts
 create mode 100644 src/hooks/leverage/velora-transaction.ts

diff --git a/src/hooks/deleverage/deleverageWithErc4626Redeem.ts b/src/hooks/deleverage/deleverageWithErc4626Redeem.ts
new file mode 100644
index 00000000..ab9625ee
--- /dev/null
+++ b/src/hooks/deleverage/deleverageWithErc4626Redeem.ts
@@ -0,0 +1,158 @@
+import { type Address, encodeAbiParameters, encodeFunctionData, maxUint256 } from 'viem';
+import morphoBundlerAbi from '@/abis/bundlerV2';
+import { withSlippageFloor } from '@/hooks/leverage/math';
+import {
+  type EnsureBundlerAuthorization,
+  type MorphoMarketParams,
+  type SendBundlerTransaction,
+  sleep,
+} from '@/hooks/leverage/transaction-shared';
+import type { Erc4626LeverageRoute } from '@/hooks/leverage/types';
+import { MONARCH_TX_IDENTIFIER } from '@/utils/morpho';
+import type { Market } from '@/utils/types';
+import { type DeleverageStepType, getDeleverageRepayBounds } from './transaction-shared';
+
+type DeleverageWithErc4626RedeemParams = {
+  account: Address;
+  autoWithdrawCollateralAmount: bigint;
+  bundlerAddress: Address;
+  ensureBundlerAuthorization: EnsureBundlerAuthorization;
+  flashLoanAmount: bigint;
+  isBundlerAuthorized: boolean | undefined;
+  market: Market;
+  marketParams: MorphoMarketParams;
+  repayBySharesAmount: bigint;
+  route: Erc4626LeverageRoute;
+  sendTransactionAsync: SendBundlerTransaction;
+  slippageBps: number;
+  updateStep: (step: DeleverageStepType) => void;
+  useCloseRoute: boolean;
+  useSignatureAuthorization: boolean;
+  withdrawCollateralAmount: bigint;
+};
+
+export const deleverageWithErc4626Redeem = async ({
+  account,
+  autoWithdrawCollateralAmount,
+  bundlerAddress,
+  ensureBundlerAuthorization,
+  flashLoanAmount,
+  isBundlerAuthorized,
+  market,
+  marketParams,
+  repayBySharesAmount,
+  route,
+  sendTransactionAsync,
+  slippageBps,
+  updateStep,
+  useCloseRoute,
+  useSignatureAuthorization,
+  withdrawCollateralAmount,
+}: DeleverageWithErc4626RedeemParams): Promise<void> => {
+  const txs: `0x${string}`[] = [];
+
+  if (useSignatureAuthorization) {
+    if (!isBundlerAuthorized) {
+      updateStep('authorize_bundler_sig');
+    }
+
+    const { authorized, authorizationTxData } = await ensureBundlerAuthorization({ mode: 'signature' });
+    if (!authorized) {
+      throw new Error('Failed to authorize Bundler via signature.');
+    }
+    if (isBundlerAuthorized && authorizationTxData) {
+      throw new Error('Authorization state changed. Please retry deleverage.');
+    }
+    if (authorizationTxData) {
+      txs.push(authorizationTxData);
+      await sleep(700);
+    }
+  } else if (!isBundlerAuthorized) {
+    updateStep('authorize_bundler_tx');
+    const { authorized } = await ensureBundlerAuthorization({ mode: 'transaction' });
+    if (!authorized) {
+      throw new Error('Failed to authorize Bundler via transaction.');
+    }
+  }
+
+  const { bundlerV2RepaySlippageAmount } = getDeleverageRepayBounds({
+    flashLoanRepayAssets: flashLoanAmount,
+    repayBySharesAmount,
+    useRepayByShares: useCloseRoute,
+  });
+
+  const loanAssetsOutSlippageFloor = withSlippageFloor(flashLoanAmount, slippageBps);
+  const callbackTxs: `0x${string}`[] = [
+    encodeFunctionData({
+      abi: morphoBundlerAbi,
+      functionName: 'morphoRepay',
+      args: [
+        marketParams,
+        useCloseRoute ? 0n : flashLoanAmount,
+        useCloseRoute ? repayBySharesAmount : 0n,
+        bundlerV2RepaySlippageAmount,
+        account,
+        '0x',
+      ],
+    }),
+    encodeFunctionData({
+      abi: morphoBundlerAbi,
+      functionName: 'morphoWithdrawCollateral',
+      // Withdraw ERC4626 shares onto the bundler because the same bundler multicall redeems them immediately.
+      args: [marketParams, withdrawCollateralAmount, bundlerAddress],
+    }),
+    encodeFunctionData({
+      abi: morphoBundlerAbi,
+      functionName: 'erc4626Redeem',
+      args: [route.collateralVault, withdrawCollateralAmount, loanAssetsOutSlippageFloor, bundlerAddress, bundlerAddress],
+    }),
+  ];
+
+  if (autoWithdrawCollateralAmount > 0n) {
+    callbackTxs.push(
+      encodeFunctionData({
+        abi: morphoBundlerAbi,
+        functionName: 'morphoWithdrawCollateral',
+        args: [marketParams, autoWithdrawCollateralAmount, account],
+      }),
+    );
+  }
+
+  const flashLoanCallbackData = encodeAbiParameters([{ type: 'bytes[]' }], [callbackTxs]);
+  txs.push(
+    encodeFunctionData({
+      abi: morphoBundlerAbi,
+      functionName: 'morphoFlashLoan',
+      args: [market.loanAsset.address as Address, flashLoanAmount, flashLoanCallbackData],
+    }),
+  );
+  // Safety net: sweep any residual loan/collateral balances from the bundler back to the user.
+  txs.push(
+    encodeFunctionData({
+      abi: morphoBundlerAbi,
+      functionName: 'erc20Transfer',
+      args: [market.loanAsset.address as Address, account, maxUint256],
+    }),
+  );
+  txs.push(
+    encodeFunctionData({
+      abi: morphoBundlerAbi,
+      functionName: 'erc20Transfer',
+      args: [market.collateralAsset.address as Address, account, maxUint256],
+    }),
+  );
+
+  updateStep('execute');
+  await sleep(700);
+
+  await sendTransactionAsync({
+    account,
+    to: bundlerAddress,
+    data: (encodeFunctionData({
+      abi: morphoBundlerAbi,
+      functionName: 'multicall',
+      args: [txs],
+    }) + MONARCH_TX_IDENTIFIER) as `0x${string}`,
+    value: 0n,
+  });
+};
diff --git a/src/hooks/deleverage/deleverageWithSwap.ts b/src/hooks/deleverage/deleverageWithSwap.ts
new file mode 100644
index 00000000..88612ca4
--- /dev/null
+++ b/src/hooks/deleverage/deleverageWithSwap.ts
@@ -0,0 +1,242 @@
+import { type Address, encodeFunctionData, keccak256, zeroHash } from 'viem';
+import { bundlerV3Abi } from '@/abis/bundlerV3';
+import { morphoGeneralAdapterV1Abi } from '@/abis/morphoGeneralAdapterV1';
+import { paraswapAdapterAbi } from '@/abis/paraswapAdapter';
+import type { VeloraPriceRoute } from '@/features/swap/api/velora';
+import {
+  buildBundler3Erc20SweepCalls,
+  type Bundler3Call,
+  encodeBundler3Calls,
+  getParaswapSellOffsets,
+  readCalldataUint256,
+} from '@/hooks/leverage/bundler3';
+import { withSlippageFloor } from '@/hooks/leverage/math';
+import {
+  type EnsureBundlerAuthorization,
+  type MorphoMarketParams,
+  type SendBundlerTransaction,
+  sleep,
+} from '@/hooks/leverage/transaction-shared';
+import type { SwapLeverageRoute } from '@/hooks/leverage/types';
+import { assertTrustedVeloraExecutionTarget, buildVeloraBundlerTransactionPayload } from '@/hooks/leverage/velora-transaction';
+import { MONARCH_TX_IDENTIFIER } from '@/utils/morpho';
+import type { Market } from '@/utils/types';
+import { type DeleverageStepType, getDeleverageRepayBounds } from './transaction-shared';
+
+type DeleverageWithSwapParams = {
+  account: Address;
+  autoWithdrawCollateralAmount: bigint;
+  bundlerAddress: Address;
+  ensureBundlerAuthorization: EnsureBundlerAuthorization;
+  flashLoanAmount: bigint;
+  isBundlerAuthorized: boolean | undefined;
+  market: Market;
+  marketParams: MorphoMarketParams;
+  maxCollateralForDebtRepay: bigint;
+  repayBySharesAmount: bigint;
+  route: SwapLeverageRoute;
+  sendTransactionAsync: SendBundlerTransaction;
+  slippageBps: number;
+  swapSellPriceRoute: VeloraPriceRoute;
+  updateStep: (step: DeleverageStepType) => void;
+  useCloseRoute: boolean;
+  withdrawCollateralAmount: bigint;
+};
+
+export const deleverageWithSwap = async ({
+  account,
+  autoWithdrawCollateralAmount,
+  bundlerAddress,
+  ensureBundlerAuthorization,
+  flashLoanAmount,
+  isBundlerAuthorized,
+  market,
+  marketParams,
+  maxCollateralForDebtRepay,
+  repayBySharesAmount,
+  route,
+  sendTransactionAsync,
+  slippageBps,
+  swapSellPriceRoute,
+  updateStep,
+  useCloseRoute,
+  withdrawCollateralAmount,
+}: DeleverageWithSwapParams): Promise<void> => {
+  if (!Number.isFinite(slippageBps) || slippageBps <= 0) {
+    throw new Error('Invalid slippage tolerance. Please set a positive slippage value.');
+  }
+
+  if (!isBundlerAuthorized) {
+    updateStep('authorize_bundler_tx');
+    const { authorized } = await ensureBundlerAuthorization({ mode: 'transaction' });
+    if (!authorized) {
+      throw new Error('Failed to authorize Bundler via transaction.');
+    }
+  }
+
+  if (useCloseRoute) {
+    if (maxCollateralForDebtRepay <= 0n) {
+      throw new Error('The exact close bound is unavailable. Refresh the quote and try again.');
+    }
+    if (withdrawCollateralAmount < maxCollateralForDebtRepay) {
+      throw new Error('Deleverage quote changed. Please review the updated preview and try again.');
+    }
+  }
+
+  const { generalAdapterRepayMaxSharePriceE27 } = getDeleverageRepayBounds({
+    flashLoanRepayAssets: flashLoanAmount,
+    repayBySharesAmount,
+    useRepayByShares: useCloseRoute,
+  });
+
+  const swapTxPayload = await buildVeloraBundlerTransactionPayload({
+    destinationTokenAddress: market.loanAsset.address,
+    destinationTokenDecimals: market.loanAsset.decimals,
+    executionAddress: route.paraswapAdapterAddress,
+    network: market.morphoBlue.chain.id,
+    priceRoute: swapSellPriceRoute,
+    quoteChangedMessage: 'Deleverage quote changed. Please review the updated preview and try again.',
+    slippageBps,
+    sourceTokenAddress: market.collateralAsset.address,
+    sourceTokenAmount: withdrawCollateralAmount,
+    sourceTokenDecimals: market.collateralAsset.decimals,
+    sourceTokenSymbol: market.collateralAsset.symbol,
+  });
+
+  assertTrustedVeloraExecutionTarget({
+    priceRoute: swapSellPriceRoute,
+    quoteChangedMessage: 'Deleverage quote changed. Please review the updated preview and try again.',
+    transactionTarget: swapTxPayload.to,
+  });
+
+  const sellOffsets = getParaswapSellOffsets(swapTxPayload.data);
+  const quotedSellCollateralAmount = BigInt(swapSellPriceRoute.srcAmount);
+  const quotedLoanAssetsOut = BigInt(swapSellPriceRoute.destAmount);
+  const calldataSellCollateralAmount = readCalldataUint256(swapTxPayload.data, sellOffsets.exactAmount);
+  const calldataQuotedLoanAssetsOut = readCalldataUint256(swapTxPayload.data, sellOffsets.quotedAmount);
+  if (
+    quotedSellCollateralAmount !== withdrawCollateralAmount ||
+    calldataSellCollateralAmount !== withdrawCollateralAmount ||
+    calldataQuotedLoanAssetsOut !== quotedLoanAssetsOut
+  ) {
+    throw new Error('Deleverage quote changed. Please review the updated preview and try again.');
+  }
+
+  const loanAssetsOutSlippageFloor = withSlippageFloor(quotedLoanAssetsOut, slippageBps);
+  if (useCloseRoute) {
+    if (loanAssetsOutSlippageFloor < flashLoanAmount) {
+      throw new Error('Deleverage quote changed. Please review the updated preview and try again.');
+    }
+  } else if (loanAssetsOutSlippageFloor <= 0n) {
+    throw new Error('Velora returned zero loan output for deleverage swap.');
+  }
+
+  const calldataLoanAssetsOutSlippageFloor = readCalldataUint256(swapTxPayload.data, sellOffsets.limitAmount);
+  if (calldataLoanAssetsOutSlippageFloor !== loanAssetsOutSlippageFloor) {
+    throw new Error('Deleverage quote changed. Please review the updated preview and try again.');
+  }
+
+  const callbackBundle: Bundler3Call[] = [
+    {
+      to: route.generalAdapterAddress,
+      data: encodeFunctionData({
+        abi: morphoGeneralAdapterV1Abi,
+        functionName: 'morphoRepay',
+        // Repay first so Morpho can release the exact collateral leg needed for the unwind.
+        args: [
+          marketParams,
+          useCloseRoute ? 0n : flashLoanAmount,
+          useCloseRoute ? repayBySharesAmount : 0n,
+          generalAdapterRepayMaxSharePriceE27,
+          account,
+          '0x',
+        ],
+      }),
+      value: 0n,
+      skipRevert: false,
+      callbackHash: zeroHash,
+    },
+    {
+      to: route.generalAdapterAddress,
+      data: encodeFunctionData({
+        abi: morphoGeneralAdapterV1Abi,
+        functionName: 'morphoWithdrawCollateral',
+        // Withdraw collateral straight into the Paraswap adapter because that contract executes the sell leg.
+        args: [marketParams, withdrawCollateralAmount, route.paraswapAdapterAddress],
+      }),
+      value: 0n,
+      skipRevert: false,
+      callbackHash: zeroHash,
+    },
+    {
+      to: route.paraswapAdapterAddress,
+      data: encodeFunctionData({
+        abi: paraswapAdapterAbi,
+        functionName: 'sell',
+        args: [
+          swapTxPayload.to,
+          swapTxPayload.data,
+          market.collateralAsset.address as Address,
+          market.loanAsset.address as Address,
+          false,
+          sellOffsets,
+          route.generalAdapterAddress,
+        ],
+      }),
+      value: 0n,
+      skipRevert: false,
+      callbackHash: zeroHash,
+    },
+  ];
+
+  if (autoWithdrawCollateralAmount > 0n) {
+    callbackBundle.push({
+      to: route.generalAdapterAddress,
+      data: encodeFunctionData({
+        abi: morphoGeneralAdapterV1Abi,
+        functionName: 'morphoWithdrawCollateral',
+        args: [marketParams, autoWithdrawCollateralAmount, account],
+      }),
+      value: 0n,
+      skipRevert: false,
+      callbackHash: zeroHash,
+    });
+  }
+
+  const callbackBundleData = encodeBundler3Calls(callbackBundle);
+  const bundleCalls: Bundler3Call[] = [
+    {
+      to: route.generalAdapterAddress,
+      data: encodeFunctionData({
+        abi: morphoGeneralAdapterV1Abi,
+        functionName: 'morphoFlashLoan',
+        args: [market.loanAsset.address as Address, flashLoanAmount, callbackBundleData],
+      }),
+      value: 0n,
+      skipRevert: false,
+      callbackHash: keccak256(callbackBundleData),
+    },
+    ...buildBundler3Erc20SweepCalls({
+      recipient: account,
+      sweepTargets: [
+        { adapterAbi: morphoGeneralAdapterV1Abi, adapterAddress: route.generalAdapterAddress },
+        { adapterAbi: paraswapAdapterAbi, adapterAddress: route.paraswapAdapterAddress },
+      ],
+      tokenAddresses: [market.loanAsset.address as Address, market.collateralAsset.address as Address],
+    }),
+  ];
+
+  updateStep('execute');
+  await sleep(700);
+
+  await sendTransactionAsync({
+    account,
+    to: bundlerAddress,
+    data: (encodeFunctionData({
+      abi: bundlerV3Abi,
+      functionName: 'multicall',
+      args: [bundleCalls],
+    }) + MONARCH_TX_IDENTIFIER) as `0x${string}`,
+    value: 0n,
+  });
+};
diff --git a/src/hooks/deleverage/transaction-shared.ts b/src/hooks/deleverage/transaction-shared.ts
new file mode 100644
index 00000000..b6aa33fc
--- /dev/null
+++ b/src/hooks/deleverage/transaction-shared.ts
@@ -0,0 +1,39 @@
+import { computeMaxSharePriceE27 } from '@/hooks/leverage/velora-precheck';
+
+export type DeleverageStepType = 'authorize_bundler_sig' | 'authorize_bundler_tx' | 'execute';
+
+export const MIN_REPAY_SHARES_SLIPPAGE_AMOUNT = 1n;
+
+/**
+ * Morpho repay slippage is mode-dependent:
+ * - repay by assets: the slippage value is a minimum shares floor
+ * - repay by shares: the slippage value is a maximum assets ceiling
+ *
+ * The Bundler V2 path passes this value directly to `morphoRepay`.
+ * The GeneralAdapter path expresses the same protection as `maxSharePriceE27`.
+ */
+export const getDeleverageRepayBounds = ({
+  flashLoanRepayAssets,
+  repayBySharesAmount,
+  useRepayByShares,
+}: {
+  flashLoanRepayAssets: bigint;
+  repayBySharesAmount: bigint;
+  useRepayByShares: boolean;
+}) => {
+  const repaySharesSlippageAmount = MIN_REPAY_SHARES_SLIPPAGE_AMOUNT;
+  const bundlerV2RepaySlippageAmount = useRepayByShares ? flashLoanRepayAssets : repaySharesSlippageAmount;
+  const generalAdapterRepayMaxSharePriceE27 = computeMaxSharePriceE27(
+    flashLoanRepayAssets,
+    useRepayByShares ? repayBySharesAmount : repaySharesSlippageAmount,
+  );
+
+  if (generalAdapterRepayMaxSharePriceE27 <= 0n) {
+    throw new Error('Invalid deleverage bounds for repay-by-shares. Refresh the quote and try again.');
+  }
+
+  return {
+    bundlerV2RepaySlippageAmount,
+    generalAdapterRepayMaxSharePriceE27,
+  };
+};
diff --git a/src/hooks/leverage/bundler3.ts b/src/hooks/leverage/bundler3.ts
index 1ed50b98..9a0a9a53 100644
--- a/src/hooks/leverage/bundler3.ts
+++ b/src/hooks/leverage/bundler3.ts
@@ -1,4 +1,4 @@
-import { type Address, encodeAbiParameters } from 'viem';
+import { type Abi, type Address, encodeAbiParameters, encodeFunctionData, maxUint256, zeroHash } from 'viem';
 
 const PARASWAP_SELL_EXACT_AMOUNT_OFFSET = 100n;
 const PARASWAP_SELL_MIN_DEST_AMOUNT_OFFSET = 132n;
@@ -53,3 +53,42 @@ export const readCalldataUint256 = (callData: `0x${string}`, offset: bigint): bi
 
   return BigInt(`0x${callData.slice(start, end)}`);
 };
+
+type Bundler3SweepTarget = {
+  adapterAbi: Abi;
+  adapterAddress: Address;
+};
+
+/**
+ * Explicitly sweep every touched adapter/token pair after execution.
+ * This keeps residual dust from remaining in Bundler3 adapters after flash-loan settlement.
+ */
+export const buildBundler3Erc20SweepCalls = ({
+  recipient,
+  sweepTargets,
+  tokenAddresses,
+}: {
+  recipient: Address;
+  sweepTargets: Bundler3SweepTarget[];
+  tokenAddresses: Address[];
+}): Bundler3Call[] => {
+  const sweepCalls: Bundler3Call[] = [];
+
+  for (const { adapterAbi, adapterAddress } of sweepTargets) {
+    for (const tokenAddress of tokenAddresses) {
+      sweepCalls.push({
+        to: adapterAddress,
+        data: encodeFunctionData({
+          abi: adapterAbi,
+          functionName: 'erc20Transfer',
+          args: [tokenAddress, recipient, maxUint256],
+        }),
+        value: 0n,
+        skipRevert: false,
+        callbackHash: zeroHash,
+      });
+    }
+  }
+
+  return sweepCalls;
+};
diff --git a/src/hooks/leverage/leverageWithErc4626Deposit.ts b/src/hooks/leverage/leverageWithErc4626Deposit.ts
index c3d4e8e3..051f1565 100644
--- a/src/hooks/leverage/leverageWithErc4626Deposit.ts
+++ b/src/hooks/leverage/leverageWithErc4626Deposit.ts
@@ -5,11 +5,11 @@ import { MONARCH_TX_IDENTIFIER } from '@/utils/morpho';
 import type { Market } from '@/utils/types';
 import { getBorrowSharesSlippageAmount, withSlippageFloor } from './math';
 import {
-  type EnsureLeverageAuthorization,
-  type LeverageMarketParams,
+  type EnsureBundlerAuthorization,
+  type MorphoMarketParams,
   type LeverageStepType,
-  type SendLeverageTransaction,
-  type SignForLeverageBundlers,
+  type SendBundlerTransaction,
+  type SignForBundlers,
   sleep,
 } from './transaction-shared';
 import type { Erc4626LeverageRoute } from './types';
@@ -18,7 +18,7 @@ type LeverageWithErc4626DepositParams = {
   account: Address;
   bundlerAddress: Address;
   market: Market;
-  marketParams: LeverageMarketParams;
+  marketParams: MorphoMarketParams;
   route: Erc4626LeverageRoute;
   collateralAmount: bigint;
   collateralAmountInCollateralToken: bigint;
@@ -32,12 +32,12 @@ type LeverageWithErc4626DepositParams = {
   permit2Authorized: boolean;
   isBundlerAuthorized: boolean | undefined;
   authorizePermit2: () => Promise<unknown>;
-  ensureBundlerAuthorization: EnsureLeverageAuthorization;
-  signForBundlers: SignForLeverageBundlers;
+  ensureBundlerAuthorization: EnsureBundlerAuthorization;
+  signForBundlers: SignForBundlers;
   isApproved: boolean;
   approve: () => Promise<unknown>;
   updateStep: (step: LeverageStepType) => void;
-  sendTransactionAsync: SendLeverageTransaction;
+  sendTransactionAsync: SendBundlerTransaction;
 };
 
 export const leverageWithErc4626Deposit = async ({
diff --git a/src/hooks/leverage/leverageWithSwap.ts b/src/hooks/leverage/leverageWithSwap.ts
index 63a8516c..6b6841c0 100644
--- a/src/hooks/leverage/leverageWithSwap.ts
+++ b/src/hooks/leverage/leverageWithSwap.ts
@@ -1,31 +1,37 @@
-import { type Address, encodeFunctionData, isAddress, isAddressEqual, keccak256, maxUint256, zeroHash } from 'viem';
+import { type Address, encodeFunctionData, keccak256, maxUint256, zeroHash } from 'viem';
 import { bundlerV3Abi } from '@/abis/bundlerV3';
 import morphoAbi from '@/abis/morpho';
 import { morphoGeneralAdapterV1Abi } from '@/abis/morphoGeneralAdapterV1';
 import { paraswapAdapterAbi } from '@/abis/paraswapAdapter';
 import permit2Abi from '@/abis/permit2';
 import { LEVERAGE_FEE_RECIPIENT } from '@/config/leverage';
-import { buildVeloraTransactionPayload, isVeloraRateChangedError, type VeloraPriceRoute } from '@/features/swap/api/velora';
+import type { VeloraPriceRoute } from '@/features/swap/api/velora';
 import { getMorphoAddress, MONARCH_TX_IDENTIFIER } from '@/utils/morpho';
 import { PERMIT2_ADDRESS } from '@/utils/permit2';
 import type { Market } from '@/utils/types';
-import { type Bundler3Call, encodeBundler3Calls, getParaswapSellOffsets, readCalldataUint256 } from './bundler3';
 import {
-  type EnsureLeverageAuthorization,
-  type LeverageMarketParams,
+  buildBundler3Erc20SweepCalls,
+  type Bundler3Call,
+  encodeBundler3Calls,
+  getParaswapSellOffsets,
+  readCalldataUint256,
+} from './bundler3';
+import {
+  type EnsureBundlerAuthorization,
+  type MorphoMarketParams,
   type LeverageStepType,
-  type SendLeverageTransaction,
-  type SignForLeverageBundlers,
+  type SendBundlerTransaction,
+  type SignForBundlers,
   sleep,
 } from './transaction-shared';
 import type { SwapLeverageRoute } from './types';
-import { isVeloraBypassablePrecheckError } from './velora-precheck';
+import { assertTrustedVeloraExecutionTarget, buildVeloraBundlerTransactionPayload } from './velora-transaction';
 
 type LeverageWithSwapParams = {
   account: Address;
   bundlerAddress: Address;
   market: Market;
-  marketParams: LeverageMarketParams;
+  marketParams: MorphoMarketParams;
   route: SwapLeverageRoute;
   inputTokenAddress: Address;
   inputTokenAmountForTransfer: bigint;
@@ -40,68 +46,12 @@ type LeverageWithSwapParams = {
   permit2Authorized: boolean;
   isBundlerAuthorized: boolean | undefined;
   authorizePermit2: () => Promise<unknown>;
-  ensureBundlerAuthorization: EnsureLeverageAuthorization;
-  signForBundlers: SignForLeverageBundlers;
+  ensureBundlerAuthorization: EnsureBundlerAuthorization;
+  signForBundlers: SignForBundlers;
   isApproved: boolean;
   approve: () => Promise<unknown>;
   updateStep: (step: LeverageStepType) => void;
-  sendTransactionAsync: SendLeverageTransaction;
-};
-
-const buildSwapTransactionPayload = async ({
-  market,
-  route,
-  totalLoanSellAmount,
-  swapPriceRoute,
-  slippageBps,
-}: {
-  market: Market;
-  route: SwapLeverageRoute;
-  totalLoanSellAmount: bigint;
-  swapPriceRoute: VeloraPriceRoute;
-  slippageBps: number;
-}) => {
-  const buildPayload = async (ignoreChecks: boolean) =>
-    buildVeloraTransactionPayload({
-      srcToken: market.loanAsset.address,
-      srcDecimals: market.loanAsset.decimals,
-      destToken: market.collateralAsset.address,
-      destDecimals: market.collateralAsset.decimals,
-      srcAmount: totalLoanSellAmount,
-      network: market.morphoBlue.chain.id,
-      userAddress: route.paraswapAdapterAddress,
-      priceRoute: swapPriceRoute,
-      slippageBps,
-      ignoreChecks,
-    });
-
-  try {
-    return await buildPayload(false);
-  } catch (buildError: unknown) {
-    if (isVeloraRateChangedError(buildError)) {
-      throw new Error('Leverage quote changed. Please review the updated preview and try again.');
-    }
-
-    if (
-      !isVeloraBypassablePrecheckError({
-        error: buildError,
-        sourceTokenAddress: market.loanAsset.address,
-        sourceTokenSymbol: market.loanAsset.symbol,
-      })
-    ) {
-      throw buildError;
-    }
-
-    try {
-      return await buildPayload(true);
-    } catch (fallbackBuildError: unknown) {
-      if (isVeloraRateChangedError(fallbackBuildError)) {
-        throw new Error('Leverage quote changed. Please review the updated preview and try again.');
-      }
-
-      throw fallbackBuildError;
-    }
-  }
+  sendTransactionAsync: SendBundlerTransaction;
 };
 
 export const leverageWithSwap = async ({
@@ -223,16 +173,14 @@ export const leverageWithSwap = async ({
     swapPriceRoute,
     slippageBps,
   });
+  assertTrustedVeloraExecutionTarget({
+    priceRoute: swapPriceRoute,
+    quoteChangedMessage: 'Leverage quote changed. Please review the updated preview and try again.',
+    transactionTarget: swapTxPayload.to,
+  });
 
-  const trustedVeloraTargets = [swapPriceRoute.contractAddress, swapPriceRoute.tokenTransferProxy].filter(
-    (candidate): candidate is Address => typeof candidate === 'string' && isAddress(candidate),
-  );
-  if (trustedVeloraTargets.length === 0 || !trustedVeloraTargets.some((target) => isAddressEqual(swapTxPayload.to, target))) {
-    throw new Error('Leverage quote changed. Please review the updated preview and try again.');
-  }
-
-  const expectedCollateralOut = isLoanAssetInput ? totalAddedCollateral : flashCollateralAmount;
-  if (expectedCollateralOut <= 0n) {
+  const collateralOutSlippageFloor = isLoanAssetInput ? totalAddedCollateral : flashCollateralAmount;
+  if (collateralOutSlippageFloor <= 0n) {
     throw new Error('Velora returned zero collateral output for leverage swap.');
   }
 
@@ -243,13 +191,13 @@ export const leverageWithSwap = async ({
   if (
     quotedSellAmount !== totalLoanSellAmount ||
     calldataSellAmount !== totalLoanSellAmount ||
-    calldataMinCollateralOut !== expectedCollateralOut
+    calldataMinCollateralOut !== collateralOutSlippageFloor
   ) {
     throw new Error('Leverage quote changed. Please review the updated preview and try again.');
   }
 
   const callbackBundle: Bundler3Call[] = [
-    // put asset into parapswap adapter for swapping.
+    // Move the sold loan asset into the Paraswap adapter, which is the contract that actually executes the swap.
     {
       to: route.generalAdapterAddress,
       data: encodeFunctionData({
@@ -385,52 +333,16 @@ export const leverageWithSwap = async ({
     skipRevert: false,
     callbackHash: keccak256(callbackBundleData),
   });
-  // Safety net: sweep any residual loan/collateral balances from adapters to the user.
+  // Safety net: sweep both assets from every adapter touched by the swap route.
   bundleCalls.push(
-    {
-      to: route.generalAdapterAddress,
-      data: encodeFunctionData({
-        abi: morphoGeneralAdapterV1Abi,
-        functionName: 'erc20Transfer',
-        args: [market.loanAsset.address as Address, account, maxUint256],
-      }),
-      value: 0n,
-      skipRevert: false,
-      callbackHash: zeroHash,
-    },
-    {
-      to: route.generalAdapterAddress,
-      data: encodeFunctionData({
-        abi: morphoGeneralAdapterV1Abi,
-        functionName: 'erc20Transfer',
-        args: [market.collateralAsset.address as Address, account, maxUint256],
-      }),
-      value: 0n,
-      skipRevert: false,
-      callbackHash: zeroHash,
-    },
-    {
-      to: route.paraswapAdapterAddress,
-      data: encodeFunctionData({
-        abi: paraswapAdapterAbi,
-        functionName: 'erc20Transfer',
-        args: [market.loanAsset.address as Address, account, maxUint256],
-      }),
-      value: 0n,
-      skipRevert: false,
-      callbackHash: zeroHash,
-    },
-    {
-      to: route.paraswapAdapterAddress,
-      data: encodeFunctionData({
-        abi: paraswapAdapterAbi,
-        functionName: 'erc20Transfer',
-        args: [market.collateralAsset.address as Address, account, maxUint256],
-      }),
-      value: 0n,
-      skipRevert: false,
-      callbackHash: zeroHash,
-    },
+    ...buildBundler3Erc20SweepCalls({
+      recipient: account,
+      sweepTargets: [
+        { adapterAbi: morphoGeneralAdapterV1Abi, adapterAddress: route.generalAdapterAddress },
+        { adapterAbi: paraswapAdapterAbi, adapterAddress: route.paraswapAdapterAddress },
+      ],
+      tokenAddresses: [market.loanAsset.address as Address, market.collateralAsset.address as Address],
+    }),
   );
 
   updateStep('execute');
@@ -447,3 +359,30 @@ export const leverageWithSwap = async ({
     value: 0n,
   });
 };
+
+const buildSwapTransactionPayload = ({
+  market,
+  route,
+  totalLoanSellAmount,
+  swapPriceRoute,
+  slippageBps,
+}: {
+  market: Market;
+  route: SwapLeverageRoute;
+  totalLoanSellAmount: bigint;
+  swapPriceRoute: VeloraPriceRoute;
+  slippageBps: number;
+}) =>
+  buildVeloraBundlerTransactionPayload({
+    destinationTokenAddress: market.collateralAsset.address,
+    destinationTokenDecimals: market.collateralAsset.decimals,
+    executionAddress: route.paraswapAdapterAddress,
+    network: market.morphoBlue.chain.id,
+    priceRoute: swapPriceRoute,
+    quoteChangedMessage: 'Leverage quote changed. Please review the updated preview and try again.',
+    slippageBps,
+    sourceTokenAddress: market.loanAsset.address,
+    sourceTokenAmount: totalLoanSellAmount,
+    sourceTokenDecimals: market.loanAsset.decimals,
+    sourceTokenSymbol: market.loanAsset.symbol,
+  });
diff --git a/src/hooks/leverage/transaction-shared.ts b/src/hooks/leverage/transaction-shared.ts
index 6f8a0b1c..f9969ba2 100644
--- a/src/hooks/leverage/transaction-shared.ts
+++ b/src/hooks/leverage/transaction-shared.ts
@@ -10,7 +10,7 @@ export type LeverageStepType =
   | 'approve_token'
   | 'execute';
 
-export type LeverageMarketParams = {
+export type MorphoMarketParams = {
   loanToken: Address;
   collateralToken: Address;
   oracle: Address;
@@ -20,13 +20,13 @@ export type LeverageMarketParams = {
 
 type AuthorizationMode = 'signature' | 'transaction';
 
-export type EnsureLeverageAuthorization = (params: { mode: AuthorizationMode }) => Promise<{
+export type EnsureBundlerAuthorization = (params: { mode: AuthorizationMode }) => Promise<{
   authorized: boolean;
   authorizationTxData: `0x${string}` | null;
   authorizationSignatureData: MorphoAuthorizationSignatureData | null;
 }>;
 
-export type Permit2LeverageSignature = {
+export type Permit2BundlerSignature = {
   sigs: `0x${string}`;
   permitSingle: {
     details: {
@@ -40,11 +40,11 @@ export type Permit2LeverageSignature = {
   };
 };
 
-export type SignForLeverageBundlers = () => Promise<Permit2LeverageSignature>;
+export type SignForBundlers = () => Promise<Permit2BundlerSignature>;
 
-export type SendLeverageTransaction = (params: { account: Address; to: Address; data: `0x${string}`; value: bigint }) => Promise<unknown>;
+export type SendBundlerTransaction = (params: { account: Address; to: Address; data: `0x${string}`; value: bigint }) => Promise<unknown>;
 
-export const buildLeverageMarketParams = (market: Market): LeverageMarketParams => ({
+export const buildMorphoMarketParams = (market: Market): MorphoMarketParams => ({
   loanToken: market.loanAsset.address as Address,
   collateralToken: market.collateralAsset.address as Address,
   oracle: market.oracleAddress as Address,
diff --git a/src/hooks/leverage/velora-transaction.ts b/src/hooks/leverage/velora-transaction.ts
new file mode 100644
index 00000000..92a25e1a
--- /dev/null
+++ b/src/hooks/leverage/velora-transaction.ts
@@ -0,0 +1,91 @@
+import { type Address, isAddress, isAddressEqual } from 'viem';
+import { buildVeloraTransactionPayload, isVeloraRateChangedError, type VeloraPriceRoute } from '@/features/swap/api/velora';
+import { isVeloraBypassablePrecheckError } from './velora-precheck';
+
+type BuildVeloraBundlerTransactionPayloadParams = {
+  destinationTokenAddress: string;
+  destinationTokenDecimals: number;
+  executionAddress: Address;
+  network: number;
+  priceRoute: VeloraPriceRoute;
+  quoteChangedMessage: string;
+  slippageBps: number;
+  sourceTokenAddress: string;
+  sourceTokenAmount: bigint;
+  sourceTokenDecimals: number;
+  sourceTokenSymbol: string;
+};
+
+export const buildVeloraBundlerTransactionPayload = async ({
+  destinationTokenAddress,
+  destinationTokenDecimals,
+  executionAddress,
+  network,
+  priceRoute,
+  quoteChangedMessage,
+  slippageBps,
+  sourceTokenAddress,
+  sourceTokenAmount,
+  sourceTokenDecimals,
+  sourceTokenSymbol,
+}: BuildVeloraBundlerTransactionPayloadParams) => {
+  const buildPayload = async (ignoreChecks: boolean) =>
+    buildVeloraTransactionPayload({
+      srcToken: sourceTokenAddress,
+      srcDecimals: sourceTokenDecimals,
+      destToken: destinationTokenAddress,
+      destDecimals: destinationTokenDecimals,
+      srcAmount: sourceTokenAmount,
+      network,
+      userAddress: executionAddress,
+      priceRoute,
+      slippageBps,
+      ignoreChecks,
+    });
+
+  try {
+    return await buildPayload(false);
+  } catch (buildError: unknown) {
+    if (isVeloraRateChangedError(buildError)) {
+      throw new Error(quoteChangedMessage);
+    }
+
+    if (
+      !isVeloraBypassablePrecheckError({
+        error: buildError,
+        sourceTokenAddress,
+        sourceTokenSymbol,
+      })
+    ) {
+      throw buildError;
+    }
+
+    try {
+      return await buildPayload(true);
+    } catch (fallbackBuildError: unknown) {
+      if (isVeloraRateChangedError(fallbackBuildError)) {
+        throw new Error(quoteChangedMessage);
+      }
+
+      throw fallbackBuildError;
+    }
+  }
+};
+
+export const assertTrustedVeloraExecutionTarget = ({
+  priceRoute,
+  quoteChangedMessage,
+  transactionTarget,
+}: {
+  priceRoute: VeloraPriceRoute;
+  quoteChangedMessage: string;
+  transactionTarget: Address;
+}) => {
+  const trustedTargets = [priceRoute.contractAddress, priceRoute.tokenTransferProxy].filter(
+    (candidate): candidate is Address => typeof candidate === 'string' && isAddress(candidate),
+  );
+
+  if (trustedTargets.length === 0 || !trustedTargets.some((target) => isAddressEqual(transactionTarget, target))) {
+    throw new Error(quoteChangedMessage);
+  }
+};
diff --git a/src/hooks/useDeleverageTransaction.ts b/src/hooks/useDeleverageTransaction.ts
index 5ff50510..d9d51f95 100644
--- a/src/hooks/useDeleverageTransaction.ts
+++ b/src/hooks/useDeleverageTransaction.ts
@@ -1,12 +1,13 @@
 import { useCallback, useMemo, useState } from 'react';
-import { type Address, encodeAbiParameters, encodeFunctionData, isAddress, isAddressEqual, keccak256, maxUint256, zeroHash } from 'viem';
+import { type Address, isAddress } from 'viem';
 import { useConnection } from 'wagmi';
-import morphoBundlerAbi from '@/abis/bundlerV2';
-import { bundlerV3Abi } from '@/abis/bundlerV3';
-import { morphoGeneralAdapterV1Abi } from '@/abis/morphoGeneralAdapterV1';
-import { paraswapAdapterAbi } from '@/abis/paraswapAdapter';
 import { resolveErc4626RouteBundler } from '@/config/leverage';
-import { buildVeloraTransactionPayload, isVeloraRateChangedError, type VeloraPriceRoute } from '@/features/swap/api/velora';
+import type { VeloraPriceRoute } from '@/features/swap/api/velora';
+import { deleverageWithErc4626Redeem } from '@/hooks/deleverage/deleverageWithErc4626Redeem';
+import { deleverageWithSwap } from '@/hooks/deleverage/deleverageWithSwap';
+import type { DeleverageStepType } from '@/hooks/deleverage/transaction-shared';
+import { buildMorphoMarketParams } from '@/hooks/leverage/transaction-shared';
+import type { LeverageRoute } from '@/hooks/leverage/types';
 import { useBundlerAuthorizationStep } from '@/hooks/useBundlerAuthorizationStep';
 import { useStyledToast } from '@/hooks/useStyledToast';
 import { useTransactionWithToast } from '@/hooks/useTransactionWithToast';
@@ -14,29 +15,24 @@ import { useTransactionTracking } from '@/hooks/useTransactionTracking';
 import { useUserMarketsCache } from '@/stores/useUserMarketsCache';
 import { useAppSettings } from '@/stores/useAppSettings';
 import { formatBalance } from '@/utils/balance';
-import { MONARCH_TX_IDENTIFIER } from '@/utils/morpho';
 import { toUserFacingTransactionErrorMessage } from '@/utils/transaction-errors';
 import type { Market } from '@/utils/types';
-import { type Bundler3Call, encodeBundler3Calls, getParaswapSellOffsets, readCalldataUint256 } from './leverage/bundler3';
-import { withSlippageFloor } from './leverage/math';
-import type { LeverageRoute } from './leverage/types';
-import { computeMaxSharePriceE27, isVeloraBypassablePrecheckError } from './leverage/velora-precheck';
 
-export type DeleverageStepType = 'authorize_bundler_sig' | 'authorize_bundler_tx' | 'execute';
+export type { DeleverageStepType } from '@/hooks/deleverage/transaction-shared';
 
 type UseDeleverageTransactionProps = {
+  autoWithdrawCollateralAmount: bigint;
+  flashLoanAmount: bigint;
   market: Market;
-  route: LeverageRoute | null;
-  withdrawCollateralAmount: bigint;
+  maxCollateralForDebtRepay: bigint;
   maxWithdrawCollateralAmount: bigint;
-  flashLoanAmount: bigint;
+  onSuccess?: () => void;
   repayBySharesAmount: bigint;
-  useCloseRoute: boolean;
-  autoWithdrawCollateralAmount: bigint;
-  maxCollateralForDebtRepay: bigint;
-  swapSellPriceRoute: VeloraPriceRoute | null;
+  route: LeverageRoute | null;
   slippageBps: number;
-  onSuccess?: () => void;
+  swapSellPriceRoute: VeloraPriceRoute | null;
+  useCloseRoute: boolean;
+  withdrawCollateralAmount: bigint;
 };
 
 /**
@@ -45,18 +41,18 @@ type UseDeleverageTransactionProps = {
  * - generalized swap-backed loops on Bundler3 + adapters
  */
 export function useDeleverageTransaction({
+  autoWithdrawCollateralAmount,
+  flashLoanAmount,
   market,
-  route,
-  withdrawCollateralAmount,
+  maxCollateralForDebtRepay,
   maxWithdrawCollateralAmount,
-  flashLoanAmount,
+  onSuccess,
   repayBySharesAmount,
-  useCloseRoute,
-  autoWithdrawCollateralAmount,
-  maxCollateralForDebtRepay,
-  swapSellPriceRoute,
+  route,
   slippageBps,
-  onSuccess,
+  swapSellPriceRoute,
+  useCloseRoute,
+  withdrawCollateralAmount,
 }: UseDeleverageTransactionProps) {
   const { usePermit2: usePermit2Setting } = useAppSettings();
   const tracking = useTransactionTracking('deleverage');
@@ -68,6 +64,7 @@ export function useDeleverageTransaction({
   const bundlerAddress = useMemo<Address | undefined>(() => {
     if (!route) return undefined;
     if (route.kind === 'swap') return route.bundler3Address;
+
     try {
       const resolvedBundler = resolveErc4626RouteBundler(market.morphoBlue.chain.id, market.uniqueKey);
       return isAddress(resolvedBundler) ? resolvedBundler : undefined;
@@ -105,7 +102,7 @@ export function useDeleverageTransaction({
     },
   });
 
-  const getStepsForFlow = useCallback((isPermit2: boolean, isSwap: boolean) => {
+  const getStepsForFlow = useCallback((isSignatureAuthorization: boolean, isSwap: boolean) => {
     if (isSwap) {
       return [
         {
@@ -121,7 +118,7 @@ export function useDeleverageTransaction({
       ];
     }
 
-    if (isPermit2) {
+    if (isSignatureAuthorization) {
       return [
         {
           id: 'authorize_bundler_sig',
@@ -154,427 +151,88 @@ export function useDeleverageTransaction({
     if (!account) {
       throw new Error('No account connected. Please connect your wallet.');
     }
-
     if (!route) {
       throw new Error('This market is not supported for deleverage.');
     }
     if (!bundlerAddress) {
       throw new Error('Deleverage route data is unavailable. Please refresh and try again.');
     }
-
     if (withdrawCollateralAmount <= 0n || flashLoanAmount <= 0n) {
       throw new Error('Invalid deleverage inputs. Set a collateral unwind amount above zero.');
     }
     if (withdrawCollateralAmount > maxWithdrawCollateralAmount) {
       throw new Error('Stale deleverage input. The maximum unwind amount changed. Please review and try again.');
     }
+    if (useCloseRoute && repayBySharesAmount <= 0n) {
+      throw new Error('Debt shares are unavailable for a full close. Refresh your position data and try again.');
+    }
 
-    try {
-      const txs: `0x${string}`[] = [];
-
-      if (useSignatureAuthorization) {
-        if (!isBundlerAuthorized) {
-          tracking.update('authorize_bundler_sig');
-        }
-        const { authorized, authorizationTxData } = await ensureBundlerAuthorization({ mode: 'signature' });
-        if (!authorized) {
-          throw new Error('Failed to authorize Bundler via signature.');
-        }
-        if (isBundlerAuthorized && authorizationTxData) {
-          throw new Error('Authorization state changed. Please retry deleverage.');
-        }
-        if (authorizationTxData) {
-          txs.push(authorizationTxData);
-          await new Promise((resolve) => setTimeout(resolve, 700));
-        }
-      } else {
-        if (!isBundlerAuthorized) {
-          tracking.update('authorize_bundler_tx');
-        }
-        const { authorized } = await ensureBundlerAuthorization({ mode: 'transaction' });
-        if (!authorized) {
-          throw new Error('Failed to authorize Bundler via transaction.');
-        }
-      }
-
-      const marketParams = {
-        loanToken: market.loanAsset.address as Address,
-        collateralToken: market.collateralAsset.address as Address,
-        oracle: market.oracleAddress as Address,
-        irm: market.irmAddress as Address,
-        lltv: BigInt(market.lltv),
-      };
-
-      const isRepayByShares = useCloseRoute;
-      if (isRepayByShares && repayBySharesAmount <= 0n) {
-        throw new Error('Debt shares are unavailable for a full close. Refresh your position data and try again.');
-      }
-      // WHY: when repaying by assets, Morpho expects a *minimum* shares bound.
-      // Using an upper-bound style estimate causes false "slippage exceeded" reverts.
-      const minRepayShares = 1n;
-      const bundlerV2RepaySlippageAmount = isRepayByShares ? flashLoanAmount : minRepayShares;
-      const generalAdapterMaxSharePriceE27 = isRepayByShares
-        ? computeMaxSharePriceE27(flashLoanAmount, repayBySharesAmount)
-        : computeMaxSharePriceE27(flashLoanAmount, minRepayShares);
-      if (generalAdapterMaxSharePriceE27 <= 0n) {
-        throw new Error('Invalid deleverage bounds for repay-by-shares. Refresh the quote and try again.');
-      }
-
-      if (route.kind === 'swap') {
-        if (!Number.isFinite(slippageBps) || slippageBps <= 0) {
-          throw new Error('Invalid slippage tolerance. Please set a positive slippage value.');
-        }
-        const swapExecutionAddress = route.paraswapAdapterAddress;
-        if (useCloseRoute) {
-          if (maxCollateralForDebtRepay <= 0n) {
-            throw new Error('The exact close bound is unavailable. Refresh the quote and try again.');
-          }
-          if (withdrawCollateralAmount < maxCollateralForDebtRepay) {
-            throw new Error('Deleverage quote changed. Please review the updated preview and try again.');
-          }
-        }
-
-        const isCloseSwap = isRepayByShares;
-        const activePriceRoute = swapSellPriceRoute;
-        if (!activePriceRoute) {
-          throw new Error('Missing Velora swap quote for deleverage.');
-        }
-
-        const swapTxPayload = await (async () => {
-          const buildPayload = async (ignoreChecks: boolean) =>
-            buildVeloraTransactionPayload({
-              srcToken: market.collateralAsset.address,
-              srcDecimals: market.collateralAsset.decimals,
-              destToken: market.loanAsset.address,
-              destDecimals: market.loanAsset.decimals,
-              srcAmount: withdrawCollateralAmount,
-              network: market.morphoBlue.chain.id,
-              userAddress: swapExecutionAddress,
-              priceRoute: activePriceRoute,
-              slippageBps,
-              ignoreChecks,
-            });
-
-          try {
-            return await buildPayload(false);
-          } catch (buildError: unknown) {
-            if (isVeloraRateChangedError(buildError)) {
-              throw new Error('Deleverage quote changed. Please review the updated preview and try again.');
-            }
-            if (
-              !isVeloraBypassablePrecheckError({
-                error: buildError,
-                sourceTokenAddress: market.collateralAsset.address,
-                sourceTokenSymbol: market.collateralAsset.symbol,
-              })
-            ) {
-              throw buildError;
-            }
-
-            try {
-              return await buildPayload(true);
-            } catch (fallbackBuildError: unknown) {
-              if (isVeloraRateChangedError(fallbackBuildError)) {
-                throw new Error('Deleverage quote changed. Please review the updated preview and try again.');
-              }
-              throw fallbackBuildError;
-            }
-          }
-        })();
-
-        const trustedVeloraTargets = [activePriceRoute.contractAddress, activePriceRoute.tokenTransferProxy].filter(
-          (candidate): candidate is Address => typeof candidate === 'string' && isAddress(candidate),
-        );
-        if (trustedVeloraTargets.length === 0 || !trustedVeloraTargets.some((target) => isAddressEqual(swapTxPayload.to, target))) {
-          throw new Error('Deleverage quote changed. Please review the updated preview and try again.');
-        }
-
-        const sellOffsets = getParaswapSellOffsets(swapTxPayload.data);
-        const quotedSellCollateral = BigInt(activePriceRoute.srcAmount);
-        const quotedLoanOut = BigInt(activePriceRoute.destAmount);
-        const calldataSellAmount = readCalldataUint256(swapTxPayload.data, sellOffsets.exactAmount);
-        const calldataQuotedLoanOut = readCalldataUint256(swapTxPayload.data, sellOffsets.quotedAmount);
-        if (
-          quotedSellCollateral !== withdrawCollateralAmount ||
-          calldataSellAmount !== withdrawCollateralAmount ||
-          calldataQuotedLoanOut !== quotedLoanOut
-        ) {
-          throw new Error('Deleverage quote changed. Please review the updated preview and try again.');
-        }
-
-        const swapCallData = swapTxPayload.data;
-        const minLoanOut = withSlippageFloor(quotedLoanOut, slippageBps);
-        if (isCloseSwap) {
-          if (minLoanOut < flashLoanAmount) {
-            throw new Error('Deleverage quote changed. Please review the updated preview and try again.');
-          }
-        } else if (minLoanOut <= 0n) {
-          throw new Error('Velora returned zero loan output for deleverage swap.');
-        }
-
-        const calldataMinLoanOut = readCalldataUint256(swapTxPayload.data, sellOffsets.limitAmount);
-        if (calldataMinLoanOut !== minLoanOut) {
-          throw new Error('Deleverage quote changed. Please review the updated preview and try again.');
-        }
-
-        const callbackBundle: Bundler3Call[] = [
-          {
-            to: route.generalAdapterAddress,
-            data: encodeFunctionData({
-              abi: morphoGeneralAdapterV1Abi,
-              functionName: 'morphoRepay',
-              args: [
-                marketParams,
-                isRepayByShares ? 0n : flashLoanAmount,
-                isRepayByShares ? repayBySharesAmount : 0n,
-                generalAdapterMaxSharePriceE27,
-                account as Address,
-                '0x',
-              ],
-            }),
-            value: 0n,
-            skipRevert: false,
-            callbackHash: zeroHash,
-          },
-          {
-            to: route.generalAdapterAddress,
-            data: encodeFunctionData({
-              abi: morphoGeneralAdapterV1Abi,
-              functionName: 'morphoWithdrawCollateral',
-              args: [marketParams, withdrawCollateralAmount, route.paraswapAdapterAddress],
-            }),
-            value: 0n,
-            skipRevert: false,
-            callbackHash: zeroHash,
-          },
-          {
-            to: route.paraswapAdapterAddress,
-            data: encodeFunctionData({
-              abi: paraswapAdapterAbi,
-              functionName: 'sell',
-              args: [
-                swapTxPayload.to,
-                swapCallData,
-                market.collateralAsset.address as Address,
-                market.loanAsset.address as Address,
-                false,
-                sellOffsets,
-                route.generalAdapterAddress,
-              ],
-            }),
-            value: 0n,
-            skipRevert: false,
-            callbackHash: zeroHash,
-          },
-        ];
-
-        if (autoWithdrawCollateralAmount > 0n) {
-          callbackBundle.push({
-            to: route.generalAdapterAddress,
-            data: encodeFunctionData({
-              abi: morphoGeneralAdapterV1Abi,
-              functionName: 'morphoWithdrawCollateral',
-              args: [marketParams, autoWithdrawCollateralAmount, account as Address],
-            }),
-            value: 0n,
-            skipRevert: false,
-            callbackHash: zeroHash,
-          });
-        }
-
-        const callbackBundleData = encodeBundler3Calls(callbackBundle);
-        const bundleCalls: Bundler3Call[] = [
-          {
-            to: route.generalAdapterAddress,
-            data: encodeFunctionData({
-              abi: morphoGeneralAdapterV1Abi,
-              functionName: 'morphoFlashLoan',
-              args: [market.loanAsset.address as Address, flashLoanAmount, callbackBundleData],
-            }),
-            value: 0n,
-            skipRevert: false,
-            callbackHash: keccak256(callbackBundleData),
-          },
-          // Safety net: sweep any residual loan/collateral balances from adapters to the user.
-          {
-            to: route.generalAdapterAddress,
-            data: encodeFunctionData({
-              abi: morphoGeneralAdapterV1Abi,
-              functionName: 'erc20Transfer',
-              args: [market.loanAsset.address as Address, account as Address, maxUint256],
-            }),
-            value: 0n,
-            skipRevert: false,
-            callbackHash: zeroHash,
-          },
-          {
-            to: route.generalAdapterAddress,
-            data: encodeFunctionData({
-              abi: morphoGeneralAdapterV1Abi,
-              functionName: 'erc20Transfer',
-              args: [market.collateralAsset.address as Address, account as Address, maxUint256],
-            }),
-            value: 0n,
-            skipRevert: false,
-            callbackHash: zeroHash,
-          },
-          {
-            to: route.paraswapAdapterAddress,
-            data: encodeFunctionData({
-              abi: paraswapAdapterAbi,
-              functionName: 'erc20Transfer',
-              args: [market.loanAsset.address as Address, account as Address, maxUint256],
-            }),
-            value: 0n,
-            skipRevert: false,
-            callbackHash: zeroHash,
-          },
-          {
-            to: route.paraswapAdapterAddress,
-            data: encodeFunctionData({
-              abi: paraswapAdapterAbi,
-              functionName: 'erc20Transfer',
-              args: [market.collateralAsset.address as Address, account as Address, maxUint256],
-            }),
-            value: 0n,
-            skipRevert: false,
-            callbackHash: zeroHash,
-          },
-        ];
-
-        tracking.update('execute');
-        await new Promise((resolve) => setTimeout(resolve, 700));
-
-        await sendTransactionAsync({
-          account,
-          to: bundlerAddress,
-          data: (encodeFunctionData({
-            abi: bundlerV3Abi,
-            functionName: 'multicall',
-            args: [bundleCalls],
-          }) + MONARCH_TX_IDENTIFIER) as `0x${string}`,
-          value: 0n,
-        });
-      } else {
-        const callbackTxs: `0x${string}`[] = [
-          encodeFunctionData({
-            abi: morphoBundlerAbi,
-            functionName: 'morphoRepay',
-            args: [
-              marketParams,
-              isRepayByShares ? 0n : flashLoanAmount,
-              isRepayByShares ? repayBySharesAmount : 0n,
-              bundlerV2RepaySlippageAmount,
-              account as Address,
-              '0x',
-            ],
-          }),
-          encodeFunctionData({
-            abi: morphoBundlerAbi,
-            functionName: 'morphoWithdrawCollateral',
-            args: [marketParams, withdrawCollateralAmount, bundlerAddress as Address],
-          }),
-        ];
-
-        const minAssetsOut = withSlippageFloor(flashLoanAmount, slippageBps);
-        callbackTxs.push(
-          encodeFunctionData({
-            abi: morphoBundlerAbi,
-            functionName: 'erc4626Redeem',
-            args: [route.collateralVault, withdrawCollateralAmount, minAssetsOut, bundlerAddress as Address, bundlerAddress as Address],
-          }),
-        );
-
-        if (autoWithdrawCollateralAmount > 0n) {
-          // WHY: if deleverage fully clears debt, keeping collateral locked in Morpho adds friction.
-          // We withdraw the remaining collateral in the same transaction so the position is closed.
-          callbackTxs.push(
-            encodeFunctionData({
-              abi: morphoBundlerAbi,
-              functionName: 'morphoWithdrawCollateral',
-              args: [marketParams, autoWithdrawCollateralAmount, account as Address],
-            }),
-          );
-        }
-
-        const flashLoanCallbackData = encodeAbiParameters([{ type: 'bytes[]' }], [callbackTxs]);
-        txs.push(
-          encodeFunctionData({
-            abi: morphoBundlerAbi,
-            functionName: 'morphoFlashLoan',
-            args: [market.loanAsset.address as Address, flashLoanAmount, flashLoanCallbackData],
-          }),
-        );
-        // Safety net: sweep any residual loan/collateral balances from bundler to the user.
-        txs.push(
-          encodeFunctionData({
-            abi: morphoBundlerAbi,
-            functionName: 'erc20Transfer',
-            args: [market.loanAsset.address as Address, account as Address, maxUint256],
-          }),
-        );
-        txs.push(
-          encodeFunctionData({
-            abi: morphoBundlerAbi,
-            functionName: 'erc20Transfer',
-            args: [market.collateralAsset.address as Address, account as Address, maxUint256],
-          }),
-        );
-
-        tracking.update('execute');
-        await new Promise((resolve) => setTimeout(resolve, 700));
+    const marketParams = buildMorphoMarketParams(market);
 
-        await sendTransactionAsync({
-          account,
-          to: bundlerAddress,
-          data: (encodeFunctionData({
-            abi: morphoBundlerAbi,
-            functionName: 'multicall',
-            args: [txs],
-          }) + MONARCH_TX_IDENTIFIER) as `0x${string}`,
-          value: 0n,
-        });
+    if (route.kind === 'swap') {
+      if (!swapSellPriceRoute) {
+        throw new Error('Missing Velora swap quote for deleverage.');
       }
 
-      batchAddUserMarkets([
-        {
-          marketUniqueKey: market.uniqueKey,
-          chainId: market.morphoBlue.chain.id,
-        },
-      ]);
-
-      tracking.complete();
-    } catch (error: unknown) {
-      tracking.fail();
-      console.error('Error during deleverage execution:', error);
-      const userFacingMessage = toUserFacingTransactionErrorMessage(error, 'An unexpected error occurred during deleverage.');
-      setExecutionError(userFacingMessage === 'User rejected transaction.' ? null : userFacingMessage);
-      if (userFacingMessage !== 'User rejected transaction.') {
-        toast.error('Deleverage Failed', userFacingMessage);
-      }
+      await deleverageWithSwap({
+        account,
+        autoWithdrawCollateralAmount,
+        bundlerAddress,
+        ensureBundlerAuthorization,
+        flashLoanAmount,
+        isBundlerAuthorized,
+        market,
+        marketParams,
+        maxCollateralForDebtRepay,
+        repayBySharesAmount,
+        route,
+        sendTransactionAsync,
+        slippageBps,
+        swapSellPriceRoute,
+        updateStep: tracking.update,
+        useCloseRoute,
+        withdrawCollateralAmount,
+      });
+      return;
     }
+
+    await deleverageWithErc4626Redeem({
+      account,
+      autoWithdrawCollateralAmount,
+      bundlerAddress,
+      ensureBundlerAuthorization,
+      flashLoanAmount,
+      isBundlerAuthorized,
+      market,
+      marketParams,
+      repayBySharesAmount,
+      route,
+      sendTransactionAsync,
+      slippageBps,
+      updateStep: tracking.update,
+      useCloseRoute,
+      useSignatureAuthorization,
+      withdrawCollateralAmount,
+    });
   }, [
     account,
+    autoWithdrawCollateralAmount,
+    bundlerAddress,
+    ensureBundlerAuthorization,
+    flashLoanAmount,
+    isBundlerAuthorized,
     market,
-    route,
-    withdrawCollateralAmount,
+    maxCollateralForDebtRepay,
     maxWithdrawCollateralAmount,
-    flashLoanAmount,
     repayBySharesAmount,
-    useCloseRoute,
-    autoWithdrawCollateralAmount,
-    maxCollateralForDebtRepay,
-    swapSellPriceRoute,
+    route,
+    sendTransactionAsync,
     slippageBps,
+    swapSellPriceRoute,
+    tracking.update,
+    useCloseRoute,
     useSignatureAuthorization,
-    isBundlerAuthorized,
-    ensureBundlerAuthorization,
-    bundlerAddress,
-    sendTransactionAsync,
-    batchAddUserMarkets,
-    tracking,
-    toast,
-    setExecutionError,
+    withdrawCollateralAmount,
   ]);
 
   const clearExecutionError = useCallback(() => {
@@ -615,6 +273,15 @@ export function useDeleverageTransaction({
       );
 
       await executeDeleverage();
+
+      batchAddUserMarkets([
+        {
+          marketUniqueKey: market.uniqueKey,
+          chainId: market.morphoBlue.chain.id,
+        },
+      ]);
+
+      tracking.complete();
     } catch (error: unknown) {
       console.error('Error in authorizeAndDeleverage:', error);
       tracking.fail();
@@ -626,20 +293,20 @@ export function useDeleverageTransaction({
     }
   }, [
     account,
-    route,
+    batchAddUserMarkets,
     bundlerAddress,
-    isBundlerAuthorized,
+    executeDeleverage,
+    getStepsForFlow,
     isBundlerAuthorizationReady,
     isBundlerAuthorizationStatusReady,
-    useSignatureAuthorization,
-    tracking,
-    getStepsForFlow,
+    isBundlerAuthorized,
     isSwapRoute,
     market,
-    withdrawCollateralAmount,
-    executeDeleverage,
+    route,
     toast,
-    setExecutionError,
+    tracking,
+    useSignatureAuthorization,
+    withdrawCollateralAmount,
   ]);
 
   const isAuthorizationStatusLoading =
diff --git a/src/hooks/useLeverageTransaction.ts b/src/hooks/useLeverageTransaction.ts
index 331a9373..3f14b61c 100644
--- a/src/hooks/useLeverageTransaction.ts
+++ b/src/hooks/useLeverageTransaction.ts
@@ -12,7 +12,7 @@ import { useTransactionWithToast } from '@/hooks/useTransactionWithToast';
 import { useTransactionTracking } from '@/hooks/useTransactionTracking';
 import { leverageWithErc4626Deposit } from '@/hooks/leverage/leverageWithErc4626Deposit';
 import { leverageWithSwap } from '@/hooks/leverage/leverageWithSwap';
-import { buildLeverageMarketParams, type LeverageStepType } from '@/hooks/leverage/transaction-shared';
+import { buildMorphoMarketParams, type LeverageStepType } from '@/hooks/leverage/transaction-shared';
 import type { LeverageRoute } from '@/hooks/leverage/types';
 import { useUserMarketsCache } from '@/stores/useUserMarketsCache';
 import { useAppSettings } from '@/stores/useAppSettings';
@@ -271,7 +271,7 @@ export function useLeverageTransaction({
     }
 
     try {
-      const marketParams = buildLeverageMarketParams(market);
+      const marketParams = buildMorphoMarketParams(market);
 
       if (route.kind === 'swap') {
         if (!swapPriceRoute) {

From a4ecf52acb9101d906c56a439a2b7adb003b743a Mon Sep 17 00:00:00 2001
From: antoncoding <antonassocareer@gmail.com>
Date: Sun, 8 Mar 2026 18:21:31 +0800
Subject: [PATCH 3/5] chore: review fixews

---
 AGENTS.md                                     |   3 +
 .../deleverage/deleverageWithErc4626Redeem.ts |  11 +-
 .../leverage/leverageWithErc4626Deposit.ts    |  16 +-
 src/hooks/useDeleverageQuote.ts               |  71 +++---
 src/hooks/useDeleverageTransaction.ts         |   1 -
 src/hooks/useLeverageQuote.ts                 |  18 +-
 src/hooks/useLeverageTransaction.ts           | 204 ++++++++++++------
 7 files changed, 204 insertions(+), 120 deletions(-)

diff --git a/AGENTS.md b/AGENTS.md
index 6ab44e82..5ea49577 100644
--- a/AGENTS.md
+++ b/AGENTS.md
@@ -156,6 +156,9 @@ When touching transaction and position flows, validation MUST include all releva
 21. **Modal UX integrity**: transaction-modal help/fee tooltips must render above modal layers via shared tooltip z-index chokepoints, and per-flow input mode toggles (for example target LTV vs amount) must persist through shared settings across modal reopen.
 22. **Chain-scoped identity integrity**: all market/token/route identity checks must be chain-scoped and use canonical identifiers (`chainId + market.uniqueKey` or `chainId + address`), including matching, dedupe keys, routing, and trust/allowlist gates.
 23. **Bundler residual-asset integrity**: any flash-loan transaction path that routes assets through Bundler/adapter balances (Bundler V2, GeneralAdapter, ParaswapAdapter) must end with explicit trailing sweeps of both loan and collateral tokens to the intended recipient across leverage/deleverage and swap/ERC4626 paths, and must keep execute-time slippage bounds consistent with quote-time slippage settings.
+24. **Deterministic flash-loan asset floors**: when a no-swap ERC4626 redeem/withdraw leg is the source of flash-loan repayment assets, its execute-time minimum asset bound must be at least the flash-loan settlement amount itself; do not apply swap-style slippage floors that allow the callback to under-return assets and fail only at final flash-loan settlement.
+25. **Deterministic ERC4626 quote/execution matching**: when a no-swap ERC4626 leverage leg uses vault previews, the execute-time operation must match the preview semantics exactly: `previewDeposit` should map to exact-asset deposit with the quoted share floor, and `previewMint` should map to exact-share mint with the quoted asset cap. Do not reuse swap-style slippage floors on either path.
+26. **Transaction-tracking preflight integrity**: do not call `tracking.start(...)` until all synchronous preflight validation for the flow has passed (account, route, quote, input, fee viability). Once tracking has started, execution helpers must either complete successfully or throw so the caller can finish the lifecycle with exactly one `tracking.complete()` or `tracking.fail()`.
 
 
 ### REQUIRED: Regression Rule Capture
diff --git a/src/hooks/deleverage/deleverageWithErc4626Redeem.ts b/src/hooks/deleverage/deleverageWithErc4626Redeem.ts
index ab9625ee..36d7a8c8 100644
--- a/src/hooks/deleverage/deleverageWithErc4626Redeem.ts
+++ b/src/hooks/deleverage/deleverageWithErc4626Redeem.ts
@@ -1,6 +1,5 @@
 import { type Address, encodeAbiParameters, encodeFunctionData, maxUint256 } from 'viem';
 import morphoBundlerAbi from '@/abis/bundlerV2';
-import { withSlippageFloor } from '@/hooks/leverage/math';
 import {
   type EnsureBundlerAuthorization,
   type MorphoMarketParams,
@@ -24,7 +23,6 @@ type DeleverageWithErc4626RedeemParams = {
   repayBySharesAmount: bigint;
   route: Erc4626LeverageRoute;
   sendTransactionAsync: SendBundlerTransaction;
-  slippageBps: number;
   updateStep: (step: DeleverageStepType) => void;
   useCloseRoute: boolean;
   useSignatureAuthorization: boolean;
@@ -43,7 +41,6 @@ export const deleverageWithErc4626Redeem = async ({
   repayBySharesAmount,
   route,
   sendTransactionAsync,
-  slippageBps,
   updateStep,
   useCloseRoute,
   useSignatureAuthorization,
@@ -81,7 +78,11 @@ export const deleverageWithErc4626Redeem = async ({
     useRepayByShares: useCloseRoute,
   });
 
-  const loanAssetsOutSlippageFloor = withSlippageFloor(flashLoanAmount, slippageBps);
+  // No swap slippage exists on the ERC4626 redeem path.
+  // This redeem leg must return at least the flash-loan settlement amount or the whole bundle
+  // would revert later during flash-loan repayment. Extra loan assets from the buffered close
+  // amount are swept back to the user, while any remaining collateral is withdrawn separately below.
+  const minLoanAssetsOut = flashLoanAmount;
   const callbackTxs: `0x${string}`[] = [
     encodeFunctionData({
       abi: morphoBundlerAbi,
@@ -104,7 +105,7 @@ export const deleverageWithErc4626Redeem = async ({
     encodeFunctionData({
       abi: morphoBundlerAbi,
       functionName: 'erc4626Redeem',
-      args: [route.collateralVault, withdrawCollateralAmount, loanAssetsOutSlippageFloor, bundlerAddress, bundlerAddress],
+      args: [route.collateralVault, withdrawCollateralAmount, minLoanAssetsOut, bundlerAddress, bundlerAddress],
     }),
   ];
 
diff --git a/src/hooks/leverage/leverageWithErc4626Deposit.ts b/src/hooks/leverage/leverageWithErc4626Deposit.ts
index 051f1565..16f8aa96 100644
--- a/src/hooks/leverage/leverageWithErc4626Deposit.ts
+++ b/src/hooks/leverage/leverageWithErc4626Deposit.ts
@@ -3,7 +3,7 @@ import morphoBundlerAbi from '@/abis/bundlerV2';
 import { LEVERAGE_FEE_RECIPIENT } from '@/config/leverage';
 import { MONARCH_TX_IDENTIFIER } from '@/utils/morpho';
 import type { Market } from '@/utils/types';
-import { getBorrowSharesSlippageAmount, withSlippageFloor } from './math';
+import { getBorrowSharesSlippageAmount } from './math';
 import {
   type EnsureBundlerAuthorization,
   type MorphoMarketParams,
@@ -133,13 +133,14 @@ export const leverageWithErc4626Deposit = async ({
   }
 
   if (isLoanAssetInput) {
-    // WHY: this lets users start with loan-token underlying for ERC4626 markets.
-    // We mint shares first so all leverage math and downstream Morpho collateral is in share units.
+    // WHY: the user provided an exact amount of loan-token assets, so this leg should deposit that
+    // exact asset amount into the vault. The share floor is the exact quote returned by previewDeposit,
+    // not a swap-style slippage floor.
     txs.push(
       encodeFunctionData({
         abi: morphoBundlerAbi,
         functionName: 'erc4626Deposit',
-        args: [route.collateralVault, collateralAmount, withSlippageFloor(collateralAmountInCollateralToken), bundlerAddress],
+        args: [route.collateralVault, collateralAmount, collateralAmountInCollateralToken, bundlerAddress],
       }),
     );
   }
@@ -147,8 +148,11 @@ export const leverageWithErc4626Deposit = async ({
   const callbackTxs: `0x${string}`[] = [
     encodeFunctionData({
       abi: morphoBundlerAbi,
-      functionName: 'erc4626Deposit',
-      args: [route.collateralVault, flashLoanAmount, withSlippageFloor(flashCollateralAmount), bundlerAddress],
+      functionName: 'erc4626Mint',
+      // Mint the exact flash-leg collateral shares quoted off-chain. If the vault now requires
+      // more than flashLoanAmount assets, revert early instead of minting fewer shares and drifting
+      // above the previewed leverage target. If it requires fewer, residual loan assets are swept later.
+      args: [route.collateralVault, flashCollateralAmount, flashLoanAmount, bundlerAddress],
     }),
   ];
 
diff --git a/src/hooks/useDeleverageQuote.ts b/src/hooks/useDeleverageQuote.ts
index 36c3c407..2f18a0e7 100644
--- a/src/hooks/useDeleverageQuote.ts
+++ b/src/hooks/useDeleverageQuote.ts
@@ -1,6 +1,7 @@
 import { useMemo } from 'react';
 import { useQuery } from '@tanstack/react-query';
-import { useReadContract } from 'wagmi';
+import { zeroAddress } from 'viem';
+import { useReadContracts } from 'wagmi';
 import { erc4626Abi } from '@/abis/erc4626';
 import { fetchVeloraPriceRoute, type VeloraPriceRoute } from '@/features/swap/api/velora';
 import { withSlippageCeil, withSlippageFloor } from './leverage/math';
@@ -54,36 +55,41 @@ export function useDeleverageQuote({
 }: UseDeleverageQuoteParams): DeleverageQuote {
   const bufferedBorrowAssets = withSlippageCeil(currentBorrowAssets, slippageBps);
   const swapExecutionAddress = route?.kind === 'swap' ? route.paraswapAdapterAddress : null;
+  const erc4626VaultAddress = route?.kind === 'erc4626' ? route.collateralVault : zeroAddress;
 
   const {
-    data: erc4626PreviewRedeem,
-    isLoading: isLoadingRedeem,
-    error: redeemError,
-  } = useReadContract({
-    address: route?.kind === 'erc4626' ? route.collateralVault : undefined,
-    abi: erc4626Abi,
-    functionName: 'previewRedeem',
-    args: [withdrawCollateralAmount],
-    chainId,
+    data: erc4626PreviewData,
+    isLoading: isLoadingErc4626Previews,
+    error: erc4626PreviewError,
+  } = useReadContracts({
+    contracts: [
+      {
+        address: erc4626VaultAddress,
+        abi: erc4626Abi,
+        functionName: 'previewRedeem',
+        // `previewRedeem(collateral shares)` -> loan-token assets returned by redeeming that exact share amount.
+        args: [withdrawCollateralAmount],
+        chainId,
+      },
+      {
+        address: erc4626VaultAddress,
+        abi: erc4626Abi,
+        functionName: 'previewWithdraw',
+        // `previewWithdraw(buffered loan assets)` -> collateral shares needed to withdraw that exact asset amount.
+        args: [bufferedBorrowAssets],
+        chainId,
+      },
+    ],
+    allowFailure: false,
     query: {
-      enabled: route?.kind === 'erc4626' && withdrawCollateralAmount > 0n,
+      enabled: route?.kind === 'erc4626' && (withdrawCollateralAmount > 0n || bufferedBorrowAssets > 0n),
     },
   });
 
-  const {
-    data: erc4626PreviewWithdrawForDebt,
-    isLoading: isLoadingWithdraw,
-    error: withdrawError,
-  } = useReadContract({
-    address: route?.kind === 'erc4626' ? route.collateralVault : undefined,
-    abi: erc4626Abi,
-    functionName: 'previewWithdraw',
-    args: [bufferedBorrowAssets],
-    chainId,
-    query: {
-      enabled: route?.kind === 'erc4626' && bufferedBorrowAssets > 0n,
-    },
-  });
+  const [previewRedeemLoanAssetsFromCollateralShares, previewWithdrawCollateralSharesForBufferedDebtAssets] = useMemo(
+    () => (erc4626PreviewData as readonly [bigint, bigint] | undefined) ?? [0n, 0n],
+    [erc4626PreviewData],
+  );
 
   const swapRepayQuoteQuery = useQuery({
     queryKey: [
@@ -181,8 +187,8 @@ export function useDeleverageQuote({
   const rawRouteRepayAmount = useMemo(() => {
     if (!route || withdrawCollateralAmount <= 0n) return 0n;
     if (route.kind === 'swap') return swapRepayQuote.rawRouteRepayAmount;
-    return (erc4626PreviewRedeem as bigint | undefined) ?? 0n;
-  }, [route, withdrawCollateralAmount, swapRepayQuote.rawRouteRepayAmount, erc4626PreviewRedeem]);
+    return previewRedeemLoanAssetsFromCollateralShares;
+  }, [route, withdrawCollateralAmount, swapRepayQuote.rawRouteRepayAmount, previewRedeemLoanAssetsFromCollateralShares]);
 
   const repayAmount = useMemo(() => {
     if (rawRouteRepayAmount <= 0n) return 0n;
@@ -200,14 +206,14 @@ export function useDeleverageQuote({
       if (!userAddress || swapMaxCollateralForDebtQuery.error) return 0n;
       return swapMaxCollateralForDebtQuery.data?.maxCollateralForDebtRepay ?? 0n;
     }
-    return (erc4626PreviewWithdrawForDebt as bigint | undefined) ?? 0n;
+    return previewWithdrawCollateralSharesForBufferedDebtAssets;
   }, [
     route,
     currentBorrowAssets,
     swapMaxCollateralForDebtQuery.data,
     swapMaxCollateralForDebtQuery.error,
     userAddress,
-    erc4626PreviewWithdrawForDebt,
+    previewWithdrawCollateralSharesForBufferedDebtAssets,
   ]);
 
   const closeRouteRequiresResolution = useMemo(() => {
@@ -280,7 +286,7 @@ export function useDeleverageQuote({
       if (!routeError) return null;
       return routeError instanceof Error ? routeError.message : 'Failed to quote Velora swap route for deleverage.';
     }
-    const routeError = redeemError ?? withdrawError;
+    const routeError = erc4626PreviewError;
     if (!routeError) return null;
     return routeError instanceof Error ? routeError.message : 'Failed to quote deleverage route';
   }, [
@@ -292,15 +298,14 @@ export function useDeleverageQuote({
     currentBorrowShares,
     swapMaxCollateralForDebtQuery.error,
     swapRepayQuoteQuery.error,
-    redeemError,
-    withdrawError,
+    erc4626PreviewError,
   ]);
 
   const isLoading =
     !!route &&
     (route.kind === 'swap'
       ? swapRepayQuoteQuery.isLoading || swapRepayQuoteQuery.isFetching || closeRouteRequiresResolution
-      : isLoadingRedeem || isLoadingWithdraw);
+      : isLoadingErc4626Previews);
 
   return {
     repayAmount,
diff --git a/src/hooks/useDeleverageTransaction.ts b/src/hooks/useDeleverageTransaction.ts
index d9d51f95..a170f13f 100644
--- a/src/hooks/useDeleverageTransaction.ts
+++ b/src/hooks/useDeleverageTransaction.ts
@@ -208,7 +208,6 @@ export function useDeleverageTransaction({
       repayBySharesAmount,
       route,
       sendTransactionAsync,
-      slippageBps,
       updateStep: tracking.update,
       useCloseRoute,
       useSignatureAuthorization,
diff --git a/src/hooks/useLeverageQuote.ts b/src/hooks/useLeverageQuote.ts
index d6fc6075..d8fbed53 100644
--- a/src/hooks/useLeverageQuote.ts
+++ b/src/hooks/useLeverageQuote.ts
@@ -54,13 +54,14 @@ export function useLeverageQuote({
   const swapExecutionAddress = route?.kind === 'swap' ? route.paraswapAdapterAddress : null;
 
   const {
-    data: erc4626PreviewDeposit,
+    data: previewDepositCollateralSharesFromUserLoanAssets,
     isLoading: isLoadingErc4626Deposit,
     error: erc4626DepositError,
   } = useReadContract({
     address: route?.kind === 'erc4626' ? route.collateralVault : undefined,
     abi: erc4626Abi,
     functionName: 'previewDeposit',
+    // `previewDeposit(user loan assets)` -> ERC4626 collateral shares minted from that exact asset input.
     args: [userInputAmount],
     chainId,
     query: {
@@ -72,9 +73,11 @@ export function useLeverageQuote({
     if (!route) return 0n;
     if (isSwapLoanAssetInput) return 0n;
     if (!isLoanAssetInput) return userInputAmount;
-    if (route.kind === 'erc4626') return (erc4626PreviewDeposit as bigint | undefined) ?? 0n;
+    // `previewDeposit(userInputAmount)` returns the ERC4626 collateral-share amount minted by
+    // depositing the user's exact loan-token asset input into the vault.
+    if (route.kind === 'erc4626') return (previewDepositCollateralSharesFromUserLoanAssets as bigint | undefined) ?? 0n;
     return 0n;
-  }, [route, isSwapLoanAssetInput, isLoanAssetInput, userInputAmount, erc4626PreviewDeposit]);
+  }, [route, isSwapLoanAssetInput, isLoanAssetInput, userInputAmount, previewDepositCollateralSharesFromUserLoanAssets]);
 
   const targetFlashCollateralAmount = useMemo(
     () => (isSwapLoanAssetInput ? 0n : computeFlashCollateralAmount(initialCollateralAmount, multiplierBps)),
@@ -82,13 +85,14 @@ export function useLeverageQuote({
   );
 
   const {
-    data: erc4626PreviewMint,
+    data: previewMintRequiredLoanAssetsForFlashCollateralShares,
     isLoading: isLoadingErc4626Mint,
     error: erc4626MintError,
   } = useReadContract({
     address: route?.kind === 'erc4626' ? route.collateralVault : undefined,
     abi: erc4626Abi,
     functionName: 'previewMint',
+    // `previewMint(target flash collateral shares)` -> loan-token assets required to mint those exact shares.
     args: [targetFlashCollateralAmount],
     chainId,
     query: {
@@ -230,13 +234,15 @@ export function useLeverageQuote({
       if (isLoanAssetInput) return swapLoanInputCombinedQuoteQuery.data?.flashLoanAmount ?? 0n;
       return swapCollateralInputQuoteQuery.data?.flashLoanAmount ?? 0n;
     }
-    return (erc4626PreviewMint as bigint | undefined) ?? 0n;
+    // `previewMint(targetFlashCollateralAmount)` returns how many loan-token assets the flash leg
+    // must source to mint that exact collateral-share amount.
+    return (previewMintRequiredLoanAssetsForFlashCollateralShares as bigint | undefined) ?? 0n;
   }, [
     route,
     isLoanAssetInput,
     swapLoanInputCombinedQuoteQuery.data?.flashLoanAmount,
     swapCollateralInputQuoteQuery.data?.flashLoanAmount,
-    erc4626PreviewMint,
+    previewMintRequiredLoanAssetsForFlashCollateralShares,
   ]);
 
   const totalAddedCollateral = useMemo(() => {
diff --git a/src/hooks/useLeverageTransaction.ts b/src/hooks/useLeverageTransaction.ts
index 3f14b61c..bb7df949 100644
--- a/src/hooks/useLeverageTransaction.ts
+++ b/src/hooks/useLeverageTransaction.ts
@@ -37,6 +37,20 @@ type UseLeverageTransactionProps = {
   onSuccess?: () => void;
 };
 
+type LeverageExecutionPreflight =
+  | {
+      account: Address;
+      leverageFeeAmount: bigint;
+      route: Extract<LeverageRoute, { kind: 'swap' }>;
+      swapPriceRoute: VeloraPriceRoute;
+    }
+  | {
+      account: Address;
+      leverageFeeAmount: bigint;
+      route: Extract<LeverageRoute, { kind: 'erc4626' }>;
+      swapPriceRoute: null;
+    };
+
 /**
  * Executes leverage transactions for:
  * - ERC4626 deterministic loops on Bundler V2
@@ -239,25 +253,25 @@ export function useLeverageTransaction({
     [inputTokenSymbol],
   );
 
-  const executeLeverage = useCallback(async () => {
+  const getLeverageExecutionPreflight = useCallback((): LeverageExecutionPreflight | null => {
     if (!account) {
       toast.info('No account connected', 'Please connect your wallet.');
-      return;
+      return null;
     }
 
     if (!route) {
       toast.info('Unsupported route', 'This market is not supported for leverage.');
-      return;
+      return null;
     }
 
     const hasCollateralOutput = route.kind === 'swap' && isLoanAssetInput ? totalAddedCollateral > 0n : flashCollateralAmount > 0n;
     if (collateralAmount <= 0n || flashLoanAmount <= 0n || !hasCollateralOutput) {
       toast.info('Invalid leverage inputs', 'Set collateral and multiplier above 1x before submitting.');
-      return;
+      return null;
     }
     if (collateralAssetPriceUsd == null || !Number.isFinite(collateralAssetPriceUsd) || collateralAssetPriceUsd <= 0) {
       toast.info('Leverage unavailable', 'Collateral price unavailable for fee calculation.');
-      return;
+      return null;
     }
 
     const leverageFeeAmount = getLeverageFee({
@@ -267,31 +281,71 @@ export function useLeverageTransaction({
     });
     if (totalAddedCollateral - leverageFeeAmount <= 0n) {
       toast.info('Leverage unavailable', 'Net collateral after fee must be positive.');
-      return;
+      return null;
     }
 
-    try {
+    if (route.kind === 'swap') {
+      if (!swapPriceRoute) {
+        toast.info('Quote unavailable', 'Missing swap quote for leverage. Refresh the preview and try again.');
+        return null;
+      }
+
+      return {
+        account: account as Address,
+        leverageFeeAmount,
+        route,
+        swapPriceRoute,
+      };
+    }
+
+    return {
+      account: account as Address,
+      leverageFeeAmount,
+      route,
+      swapPriceRoute: null,
+    };
+  }, [
+    account,
+    route,
+    isLoanAssetInput,
+    totalAddedCollateral,
+    flashCollateralAmount,
+    collateralAmount,
+    flashLoanAmount,
+    collateralAssetPriceUsd,
+    market.collateralAsset.decimals,
+    swapPriceRoute,
+    toast,
+  ]);
+
+  const executeLeverage = useCallback(
+    async (
+      execution: LeverageExecutionPreflight & {
+        updateStep: (step: LeverageStepType) => void;
+      },
+    ) => {
       const marketParams = buildMorphoMarketParams(market);
 
-      if (route.kind === 'swap') {
-        if (!swapPriceRoute) {
+      if (execution.route.kind === 'swap') {
+        const swapExecutionPriceRoute = execution.swapPriceRoute;
+        if (!swapExecutionPriceRoute) {
           throw new Error('Missing Velora swap quote for leverage.');
         }
 
         await leverageWithSwap({
-          account: account as Address,
+          account: execution.account,
           bundlerAddress,
           market,
           marketParams,
-          route,
+          route: execution.route,
           inputTokenAddress,
           inputTokenAmountForTransfer,
           isLoanAssetInput,
           flashLoanAmount,
           flashCollateralAmount,
           totalAddedCollateral,
-          leverageFeeAmount,
-          swapPriceRoute,
+          leverageFeeAmount: execution.leverageFeeAmount,
+          swapPriceRoute: swapExecutionPriceRoute,
           slippageBps,
           usePermit2: usePermit2ForRoute,
           permit2Authorized,
@@ -301,16 +355,16 @@ export function useLeverageTransaction({
           signForBundlers,
           isApproved,
           approve,
-          updateStep: tracking.update,
+          updateStep: execution.updateStep,
           sendTransactionAsync,
         });
       } else {
         await leverageWithErc4626Deposit({
-          account: account as Address,
+          account: execution.account,
           bundlerAddress,
           market,
           marketParams,
-          route,
+          route: execution.route,
           collateralAmount,
           collateralAmountInCollateralToken,
           inputTokenAddress,
@@ -318,7 +372,7 @@ export function useLeverageTransaction({
           isLoanAssetInput,
           flashCollateralAmount,
           flashLoanAmount,
-          leverageFeeAmount,
+          leverageFeeAmount: execution.leverageFeeAmount,
           usePermit2: usePermit2ForRoute,
           permit2Authorized,
           isBundlerAuthorized,
@@ -327,56 +381,34 @@ export function useLeverageTransaction({
           signForBundlers,
           isApproved,
           approve,
-          updateStep: tracking.update,
+          updateStep: execution.updateStep,
           sendTransactionAsync,
         });
       }
-
-      batchAddUserMarkets([
-        {
-          marketUniqueKey: market.uniqueKey,
-          chainId: market.morphoBlue.chain.id,
-        },
-      ]);
-
-      tracking.complete();
-    } catch (error: unknown) {
-      tracking.fail();
-      console.error('Error during leverage execution:', error);
-      const userFacingMessage = toUserFacingTransactionErrorMessage(error, 'An unexpected error occurred during leverage.');
-      if (userFacingMessage !== 'User rejected transaction.') {
-        toast.error('Leverage Failed', userFacingMessage);
-      }
-    }
-  }, [
-    account,
-    route,
-    market,
-    collateralAmount,
-    collateralAmountInCollateralToken,
-    inputTokenAddress,
-    inputTokenAmountForTransfer,
-    isLoanAssetInput,
-    flashCollateralAmount,
-    flashLoanAmount,
-    totalAddedCollateral,
-    collateralAssetPriceUsd,
-    swapPriceRoute,
-    slippageBps,
-    usePermit2ForRoute,
-    permit2Authorized,
-    isBundlerAuthorized,
-    authorizePermit2,
-    ensureBundlerAuthorization,
-    signForBundlers,
-    isApproved,
-    approve,
-    bundlerAddress,
-    sendTransactionAsync,
-    batchAddUserMarkets,
-    tracking,
-    toast,
-  ]);
+    },
+    [
+      market,
+      bundlerAddress,
+      collateralAmount,
+      collateralAmountInCollateralToken,
+      inputTokenAddress,
+      inputTokenAmountForTransfer,
+      isLoanAssetInput,
+      flashLoanAmount,
+      flashCollateralAmount,
+      totalAddedCollateral,
+      slippageBps,
+      usePermit2ForRoute,
+      permit2Authorized,
+      isBundlerAuthorized,
+      authorizePermit2,
+      ensureBundlerAuthorization,
+      signForBundlers,
+      isApproved,
+      approve,
+      sendTransactionAsync,
+    ],
+  );
 
   const runLeverageFlow = useCallback(
     async ({
@@ -390,14 +422,37 @@ export function useLeverageTransaction({
       errorTitle: string;
       logLabel: string;
     }) => {
-      if (!account) {
-        toast.info('No account connected', 'Please connect your wallet.');
+      const preflight = getLeverageExecutionPreflight();
+      if (!preflight) {
         return;
       }
 
+      const steps = getStepsForFlow(usePermit2Flow, isSwapRoute);
+      const stepIndexes = new Map(steps.map((step, index) => [step.id, index]));
+      let highestStepIndex = stepIndexes.get(initialStep) ?? -1;
+      const updateTrackedStep = (step: LeverageStepType) => {
+        const nextIndex = stepIndexes.get(step) ?? -1;
+        if (nextIndex > highestStepIndex) {
+          highestStepIndex = nextIndex;
+          tracking.update(step);
+        }
+      };
+
       try {
-        tracking.start(getStepsForFlow(usePermit2Flow, isSwapRoute), trackingMetadata, initialStep);
-        await executeLeverage();
+        tracking.start(steps, trackingMetadata, initialStep);
+        await executeLeverage({
+          ...preflight,
+          updateStep: updateTrackedStep,
+        });
+
+        batchAddUserMarkets([
+          {
+            marketUniqueKey: market.uniqueKey,
+            chainId: market.morphoBlue.chain.id,
+          },
+        ]);
+
+        tracking.complete();
       } catch (error: unknown) {
         console.error(`Error in ${logLabel}:`, error);
         tracking.fail();
@@ -407,7 +462,18 @@ export function useLeverageTransaction({
         }
       }
     },
-    [account, tracking, getStepsForFlow, isSwapRoute, trackingMetadata, executeLeverage, toast],
+    [
+      getLeverageExecutionPreflight,
+      getStepsForFlow,
+      isSwapRoute,
+      trackingMetadata,
+      executeLeverage,
+      batchAddUserMarkets,
+      market.uniqueKey,
+      market.morphoBlue.chain.id,
+      tracking,
+      toast,
+    ],
   );
 
   const approveAndLeverage = useCallback(async () => {

From 14c5313cfba267b17481d571394dcdd8c06a9016 Mon Sep 17 00:00:00 2001
From: antoncoding <antonassocareer@gmail.com>
Date: Sun, 8 Mar 2026 19:45:55 +0800
Subject: [PATCH 4/5] chore: rename and review fixes

---
 AGENTS.md                                     |   1 +
 .../deleverage/deleverageWithErc4626Redeem.ts |  12 +-
 .../leverage/leverageWithErc4626Deposit.ts    |  42 ++---
 src/hooks/leverage/leverageWithSwap.ts        |  40 ++---
 src/hooks/useDeleverageTransaction.ts         |   9 +-
 src/hooks/useLeverageQuote.ts                 | 150 ++++++++++--------
 src/hooks/useLeverageTransaction.ts           | 136 ++++++++--------
 .../add-collateral-and-leverage.tsx           | 109 +++++++------
 8 files changed, 277 insertions(+), 222 deletions(-)

diff --git a/AGENTS.md b/AGENTS.md
index 5ea49577..3bd2ffa5 100644
--- a/AGENTS.md
+++ b/AGENTS.md
@@ -159,6 +159,7 @@ When touching transaction and position flows, validation MUST include all releva
 24. **Deterministic flash-loan asset floors**: when a no-swap ERC4626 redeem/withdraw leg is the source of flash-loan repayment assets, its execute-time minimum asset bound must be at least the flash-loan settlement amount itself; do not apply swap-style slippage floors that allow the callback to under-return assets and fail only at final flash-loan settlement.
 25. **Deterministic ERC4626 quote/execution matching**: when a no-swap ERC4626 leverage leg uses vault previews, the execute-time operation must match the preview semantics exactly: `previewDeposit` should map to exact-asset deposit with the quoted share floor, and `previewMint` should map to exact-share mint with the quoted asset cap. Do not reuse swap-style slippage floors on either path.
 26. **Transaction-tracking preflight integrity**: do not call `tracking.start(...)` until all synchronous preflight validation for the flow has passed (account, route, quote, input, fee viability). Once tracking has started, execution helpers must either complete successfully or throw so the caller can finish the lifecycle with exactly one `tracking.complete()` or `tracking.fail()`.
+27. **Close-route collateral handoff integrity**: when a deleverage projection derives an exact close-bound collateral amount for full-repay-by-shares, route-specific executors must receive and use that quote-derived close bound explicitly for withdraw/redeem steps instead of relying on the raw user input amount. Any remaining collateral must be returned through the dedicated post-close withdraw/sweep path.
 
 
 ### REQUIRED: Regression Rule Capture
diff --git a/src/hooks/deleverage/deleverageWithErc4626Redeem.ts b/src/hooks/deleverage/deleverageWithErc4626Redeem.ts
index 36d7a8c8..5042d86b 100644
--- a/src/hooks/deleverage/deleverageWithErc4626Redeem.ts
+++ b/src/hooks/deleverage/deleverageWithErc4626Redeem.ts
@@ -15,6 +15,11 @@ type DeleverageWithErc4626RedeemParams = {
   account: Address;
   autoWithdrawCollateralAmount: bigint;
   bundlerAddress: Address;
+  /**
+   * Exact market collateral-share amount to route through the repay/redeem leg.
+   * On full-close-by-shares this must come from the quote-derived close bound, not the raw input field.
+   */
+  collateralToRedeem: bigint;
   ensureBundlerAuthorization: EnsureBundlerAuthorization;
   flashLoanAmount: bigint;
   isBundlerAuthorized: boolean | undefined;
@@ -26,13 +31,13 @@ type DeleverageWithErc4626RedeemParams = {
   updateStep: (step: DeleverageStepType) => void;
   useCloseRoute: boolean;
   useSignatureAuthorization: boolean;
-  withdrawCollateralAmount: bigint;
 };
 
 export const deleverageWithErc4626Redeem = async ({
   account,
   autoWithdrawCollateralAmount,
   bundlerAddress,
+  collateralToRedeem,
   ensureBundlerAuthorization,
   flashLoanAmount,
   isBundlerAuthorized,
@@ -44,7 +49,6 @@ export const deleverageWithErc4626Redeem = async ({
   updateStep,
   useCloseRoute,
   useSignatureAuthorization,
-  withdrawCollateralAmount,
 }: DeleverageWithErc4626RedeemParams): Promise<void> => {
   const txs: `0x${string}`[] = [];
 
@@ -100,12 +104,12 @@ export const deleverageWithErc4626Redeem = async ({
       abi: morphoBundlerAbi,
       functionName: 'morphoWithdrawCollateral',
       // Withdraw ERC4626 shares onto the bundler because the same bundler multicall redeems them immediately.
-      args: [marketParams, withdrawCollateralAmount, bundlerAddress],
+      args: [marketParams, collateralToRedeem, bundlerAddress],
     }),
     encodeFunctionData({
       abi: morphoBundlerAbi,
       functionName: 'erc4626Redeem',
-      args: [route.collateralVault, withdrawCollateralAmount, minLoanAssetsOut, bundlerAddress, bundlerAddress],
+      args: [route.collateralVault, collateralToRedeem, minLoanAssetsOut, bundlerAddress, bundlerAddress],
     }),
   ];
 
diff --git a/src/hooks/leverage/leverageWithErc4626Deposit.ts b/src/hooks/leverage/leverageWithErc4626Deposit.ts
index 16f8aa96..113782dc 100644
--- a/src/hooks/leverage/leverageWithErc4626Deposit.ts
+++ b/src/hooks/leverage/leverageWithErc4626Deposit.ts
@@ -20,13 +20,15 @@ type LeverageWithErc4626DepositParams = {
   market: Market;
   marketParams: MorphoMarketParams;
   route: Erc4626LeverageRoute;
-  collateralAmount: bigint;
-  collateralAmountInCollateralToken: bigint;
-  inputTokenAddress: Address;
-  inputTokenAmountForTransfer: bigint;
+  /** Exact user-entered starting capital, denominated by `isLoanAssetInput`. */
+  initialCapitalInputAmount: bigint;
+  /** Market collateral-token amount sourced from the initial capital before the flash leg. */
+  initialCapitalCollateralTokenAmount: bigint;
+  initialCapitalInputTokenAddress: Address;
+  initialCapitalTransferAmount: bigint;
   isLoanAssetInput: boolean;
-  flashCollateralAmount: bigint;
-  flashLoanAmount: bigint; // amount to flashloan in loan asset
+  flashLegCollateralTokenAmount: bigint;
+  flashLoanAssetAmount: bigint; // amount to flashloan in loan asset
   leverageFeeAmount: bigint;
   usePermit2: boolean;
   permit2Authorized: boolean;
@@ -46,13 +48,13 @@ export const leverageWithErc4626Deposit = async ({
   market,
   marketParams,
   route,
-  collateralAmount,
-  collateralAmountInCollateralToken,
-  inputTokenAddress,
-  inputTokenAmountForTransfer,
+  initialCapitalInputAmount,
+  initialCapitalCollateralTokenAmount,
+  initialCapitalInputTokenAddress,
+  initialCapitalTransferAmount,
   isLoanAssetInput,
-  flashCollateralAmount,
-  flashLoanAmount,
+  flashLegCollateralTokenAmount,
+  flashLoanAssetAmount,
   leverageFeeAmount,
   usePermit2,
   permit2Authorized,
@@ -117,17 +119,17 @@ export const leverageWithErc4626Deposit = async ({
 
   // Asset-based borrow uses an exact asset amount plus a max-share slippage bound.
   const borrowSharesSlippageAmount = getBorrowSharesSlippageAmount({
-    borrowAssets: flashLoanAmount,
+    borrowAssets: flashLoanAssetAmount,
     totalBorrowAssets: BigInt(market.state.borrowAssets),
     totalBorrowShares: BigInt(market.state.borrowShares),
   });
 
-  if (inputTokenAmountForTransfer > 0n) {
+  if (initialCapitalTransferAmount > 0n) {
     txs.push(
       encodeFunctionData({
         abi: morphoBundlerAbi,
         functionName: usePermit2 ? 'transferFrom2' : 'erc20TransferFrom',
-        args: [inputTokenAddress, inputTokenAmountForTransfer],
+        args: [initialCapitalInputTokenAddress, initialCapitalTransferAmount],
       }),
     );
   }
@@ -140,7 +142,7 @@ export const leverageWithErc4626Deposit = async ({
       encodeFunctionData({
         abi: morphoBundlerAbi,
         functionName: 'erc4626Deposit',
-        args: [route.collateralVault, collateralAmount, collateralAmountInCollateralToken, bundlerAddress],
+        args: [route.collateralVault, initialCapitalInputAmount, initialCapitalCollateralTokenAmount, bundlerAddress],
       }),
     );
   }
@@ -150,9 +152,9 @@ export const leverageWithErc4626Deposit = async ({
       abi: morphoBundlerAbi,
       functionName: 'erc4626Mint',
       // Mint the exact flash-leg collateral shares quoted off-chain. If the vault now requires
-      // more than flashLoanAmount assets, revert early instead of minting fewer shares and drifting
+      // more than flashLoanAssetAmount assets, revert early instead of minting fewer shares and drifting
       // above the previewed leverage target. If it requires fewer, residual loan assets are swept later.
-      args: [route.collateralVault, flashCollateralAmount, flashLoanAmount, bundlerAddress],
+      args: [route.collateralVault, flashLegCollateralTokenAmount, flashLoanAssetAmount, bundlerAddress],
     }),
   ];
 
@@ -179,7 +181,7 @@ export const leverageWithErc4626Deposit = async ({
     encodeFunctionData({
       abi: morphoBundlerAbi,
       functionName: 'morphoBorrow',
-      args: [marketParams, flashLoanAmount, 0n, borrowSharesSlippageAmount, bundlerAddress],
+      args: [marketParams, flashLoanAssetAmount, 0n, borrowSharesSlippageAmount, bundlerAddress],
     }),
   );
 
@@ -188,7 +190,7 @@ export const leverageWithErc4626Deposit = async ({
     encodeFunctionData({
       abi: morphoBundlerAbi,
       functionName: 'morphoFlashLoan',
-      args: [market.loanAsset.address as Address, flashLoanAmount, flashLoanCallbackData],
+      args: [market.loanAsset.address as Address, flashLoanAssetAmount, flashLoanCallbackData],
     }),
   );
   // Safety net: sweep any residual loan/collateral balances from bundler to the user.
diff --git a/src/hooks/leverage/leverageWithSwap.ts b/src/hooks/leverage/leverageWithSwap.ts
index 6b6841c0..a8b8794a 100644
--- a/src/hooks/leverage/leverageWithSwap.ts
+++ b/src/hooks/leverage/leverageWithSwap.ts
@@ -33,12 +33,12 @@ type LeverageWithSwapParams = {
   market: Market;
   marketParams: MorphoMarketParams;
   route: SwapLeverageRoute;
-  inputTokenAddress: Address;
-  inputTokenAmountForTransfer: bigint;
+  initialCapitalInputTokenAddress: Address;
+  initialCapitalTransferAmount: bigint;
   isLoanAssetInput: boolean;
-  flashLoanAmount: bigint;
-  flashCollateralAmount: bigint;
-  totalAddedCollateral: bigint;
+  flashLoanAssetAmount: bigint;
+  flashLegCollateralTokenAmount: bigint;
+  totalCollateralTokenAmountAdded: bigint;
   leverageFeeAmount: bigint;
   swapPriceRoute: VeloraPriceRoute;
   slippageBps: number;
@@ -60,12 +60,12 @@ export const leverageWithSwap = async ({
   market,
   marketParams,
   route,
-  inputTokenAddress,
-  inputTokenAmountForTransfer,
+  initialCapitalInputTokenAddress,
+  initialCapitalTransferAmount,
   isLoanAssetInput,
-  flashLoanAmount,
-  flashCollateralAmount,
-  totalAddedCollateral,
+  flashLoanAssetAmount,
+  flashLegCollateralTokenAmount,
+  totalCollateralTokenAmountAdded,
   leverageFeeAmount,
   swapPriceRoute,
   slippageBps,
@@ -85,14 +85,14 @@ export const leverageWithSwap = async ({
   }
 
   const preFlashCollateralFee =
-    !isLoanAssetInput && inputTokenAmountForTransfer > 0n
-      ? leverageFeeAmount < inputTokenAmountForTransfer
+    !isLoanAssetInput && initialCapitalTransferAmount > 0n
+      ? leverageFeeAmount < initialCapitalTransferAmount
         ? leverageFeeAmount
-        : inputTokenAmountForTransfer
+        : initialCapitalTransferAmount
       : 0n;
   const callbackCollateralFee = leverageFeeAmount - preFlashCollateralFee;
-  const preFlashCollateralSupplyAmount = inputTokenAmountForTransfer - preFlashCollateralFee;
-  const totalLoanSellAmount = isLoanAssetInput ? inputTokenAmountForTransfer + flashLoanAmount : flashLoanAmount;
+  const preFlashCollateralSupplyAmount = initialCapitalTransferAmount - preFlashCollateralFee;
+  const totalLoanSellAmount = isLoanAssetInput ? initialCapitalTransferAmount + flashLoanAssetAmount : flashLoanAssetAmount;
   if (totalLoanSellAmount <= 0n) {
     throw new Error('Invalid total sell amount for swap-backed leverage.');
   }
@@ -179,7 +179,7 @@ export const leverageWithSwap = async ({
     transactionTarget: swapTxPayload.to,
   });
 
-  const collateralOutSlippageFloor = isLoanAssetInput ? totalAddedCollateral : flashCollateralAmount;
+  const collateralOutSlippageFloor = isLoanAssetInput ? totalCollateralTokenAmountAdded : flashLegCollateralTokenAmount;
   if (collateralOutSlippageFloor <= 0n) {
     throw new Error('Velora returned zero collateral output for leverage swap.');
   }
@@ -262,7 +262,7 @@ export const leverageWithSwap = async ({
         abi: morphoGeneralAdapterV1Abi,
         functionName: 'morphoBorrow',
         // receive the flashloan in general adapter address
-        args: [marketParams, flashLoanAmount, 0n, 0n, route.generalAdapterAddress],
+        args: [marketParams, flashLoanAssetAmount, 0n, 0n, route.generalAdapterAddress],
       }),
       value: 0n,
       skipRevert: false,
@@ -279,13 +279,13 @@ export const leverageWithSwap = async ({
     bundleCalls.push(permit2Call);
   }
 
-  if (inputTokenAmountForTransfer > 0n) {
+  if (initialCapitalTransferAmount > 0n) {
     bundleCalls.push({
       to: route.generalAdapterAddress,
       data: encodeFunctionData({
         abi: morphoGeneralAdapterV1Abi,
         functionName: usePermit2 ? 'permit2TransferFrom' : 'erc20TransferFrom',
-        args: [inputTokenAddress, route.generalAdapterAddress, inputTokenAmountForTransfer],
+        args: [initialCapitalInputTokenAddress, route.generalAdapterAddress, initialCapitalTransferAmount],
       }),
       value: 0n,
       skipRevert: false,
@@ -327,7 +327,7 @@ export const leverageWithSwap = async ({
     data: encodeFunctionData({
       abi: morphoGeneralAdapterV1Abi,
       functionName: 'morphoFlashLoan',
-      args: [market.loanAsset.address as Address, flashLoanAmount, callbackBundleData],
+      args: [market.loanAsset.address as Address, flashLoanAssetAmount, callbackBundleData],
     }),
     value: 0n,
     skipRevert: false,
diff --git a/src/hooks/useDeleverageTransaction.ts b/src/hooks/useDeleverageTransaction.ts
index a170f13f..2894bb86 100644
--- a/src/hooks/useDeleverageTransaction.ts
+++ b/src/hooks/useDeleverageTransaction.ts
@@ -166,6 +166,13 @@ export function useDeleverageTransaction({
     if (useCloseRoute && repayBySharesAmount <= 0n) {
       throw new Error('Debt shares are unavailable for a full close. Refresh your position data and try again.');
     }
+    const collateralToRedeem = useCloseRoute ? maxCollateralForDebtRepay : withdrawCollateralAmount;
+    if (collateralToRedeem <= 0n) {
+      throw new Error('Collateral redeem amount is unavailable. Refresh the deleverage quote and try again.');
+    }
+    if (useCloseRoute && withdrawCollateralAmount < collateralToRedeem) {
+      throw new Error('Deleverage quote changed. Please review the updated preview and try again.');
+    }
 
     const marketParams = buildMorphoMarketParams(market);
 
@@ -200,6 +207,7 @@ export function useDeleverageTransaction({
       account,
       autoWithdrawCollateralAmount,
       bundlerAddress,
+      collateralToRedeem,
       ensureBundlerAuthorization,
       flashLoanAmount,
       isBundlerAuthorized,
@@ -211,7 +219,6 @@ export function useDeleverageTransaction({
       updateStep: tracking.update,
       useCloseRoute,
       useSignatureAuthorization,
-      withdrawCollateralAmount,
     });
   }, [
     account,
diff --git a/src/hooks/useLeverageQuote.ts b/src/hooks/useLeverageQuote.ts
index d8fbed53..1d509dc7 100644
--- a/src/hooks/useLeverageQuote.ts
+++ b/src/hooks/useLeverageQuote.ts
@@ -9,7 +9,12 @@ import type { LeverageRoute } from './leverage/types';
 type UseLeverageQuoteParams = {
   chainId: number;
   route: LeverageRoute | null;
-  userInputAmount: bigint;
+  /**
+   * Exact user-entered starting capital, denominated by `inputMode`.
+   * - `loan`: market loan asset amount
+   * - `collateral`: market collateral token amount
+   */
+  initialCapitalInputAmount: bigint;
   inputMode: 'collateral' | 'loan';
   slippageBps: number;
   multiplierBps: bigint;
@@ -21,10 +26,25 @@ type UseLeverageQuoteParams = {
 };
 
 export type LeverageQuote = {
-  initialCollateralAmount: bigint;
-  flashCollateralAmount: bigint;
-  flashLoanAmount: bigint;
-  totalAddedCollateral: bigint;
+  /**
+   * Market collateral-token amount sourced directly from the user's starting capital before the flash leg.
+   *
+   * - collateral-input mode: equals `initialCapitalInputAmount`
+   * - ERC4626 loan-input mode: `previewDeposit(initialCapitalInputAmount)`
+   * - swap loan-input mode: `0n` because the user loan input is sold together with the flash leg
+   */
+  initialCapitalCollateralTokenAmount: bigint;
+  /**
+   * Additional market collateral-token amount sourced by the flash leg.
+   *
+   * - ERC4626 route: exact vault share amount minted in the callback
+   * - swap route: minimum collateral output expected from selling the flash-borrowed loan asset
+   */
+  flashLegCollateralTokenAmount: bigint;
+  /** Flash-loaned market loan-asset amount. */
+  flashLoanAssetAmount: bigint;
+  /** Total market collateral-token amount added before leverage fee. */
+  totalCollateralTokenAmountAdded: bigint;
   isLoading: boolean;
   error: string | null;
   swapPriceRoute: VeloraPriceRoute | null;
@@ -33,13 +53,13 @@ export type LeverageQuote = {
 /**
  * Converts user leverage intent into deterministic route amounts.
  *
- * - `flashCollateralAmount`: extra collateral target sourced via the flash leg
- * - `flashLoanAmount`: debt token flash amount needed to mint that extra collateral
+ * - `flashLegCollateralTokenAmount`: extra market collateral-token amount sourced via the flash leg
+ * - `flashLoanAssetAmount`: market loan-asset amount needed to source that extra collateral
  */
 export function useLeverageQuote({
   chainId,
   route,
-  userInputAmount,
+  initialCapitalInputAmount,
   inputMode,
   slippageBps,
   multiplierBps,
@@ -62,26 +82,26 @@ export function useLeverageQuote({
     abi: erc4626Abi,
     functionName: 'previewDeposit',
     // `previewDeposit(user loan assets)` -> ERC4626 collateral shares minted from that exact asset input.
-    args: [userInputAmount],
+    args: [initialCapitalInputAmount],
     chainId,
     query: {
-      enabled: route?.kind === 'erc4626' && isLoanAssetInput && userInputAmount > 0n,
+      enabled: route?.kind === 'erc4626' && isLoanAssetInput && initialCapitalInputAmount > 0n,
     },
   });
 
-  const initialCollateralAmount = useMemo(() => {
+  const initialCapitalCollateralTokenAmount = useMemo(() => {
     if (!route) return 0n;
     if (isSwapLoanAssetInput) return 0n;
-    if (!isLoanAssetInput) return userInputAmount;
-    // `previewDeposit(userInputAmount)` returns the ERC4626 collateral-share amount minted by
+    if (!isLoanAssetInput) return initialCapitalInputAmount;
+    // `previewDeposit(initialCapitalInputAmount)` returns the ERC4626 collateral-share amount minted by
     // depositing the user's exact loan-token asset input into the vault.
     if (route.kind === 'erc4626') return (previewDepositCollateralSharesFromUserLoanAssets as bigint | undefined) ?? 0n;
     return 0n;
-  }, [route, isSwapLoanAssetInput, isLoanAssetInput, userInputAmount, previewDepositCollateralSharesFromUserLoanAssets]);
+  }, [route, isSwapLoanAssetInput, isLoanAssetInput, initialCapitalInputAmount, previewDepositCollateralSharesFromUserLoanAssets]);
 
-  const targetFlashCollateralAmount = useMemo(
-    () => (isSwapLoanAssetInput ? 0n : computeFlashCollateralAmount(initialCollateralAmount, multiplierBps)),
-    [isSwapLoanAssetInput, initialCollateralAmount, multiplierBps],
+  const targetFlashCollateralTokenAmount = useMemo(
+    () => (isSwapLoanAssetInput ? 0n : computeFlashCollateralAmount(initialCapitalCollateralTokenAmount, multiplierBps)),
+    [isSwapLoanAssetInput, initialCapitalCollateralTokenAmount, multiplierBps],
   );
 
   const {
@@ -93,10 +113,10 @@ export function useLeverageQuote({
     abi: erc4626Abi,
     functionName: 'previewMint',
     // `previewMint(target flash collateral shares)` -> loan-token assets required to mint those exact shares.
-    args: [targetFlashCollateralAmount],
+    args: [targetFlashCollateralTokenAmount],
     chainId,
     query: {
-      enabled: route?.kind === 'erc4626' && targetFlashCollateralAmount > 0n,
+      enabled: route?.kind === 'erc4626' && targetFlashCollateralTokenAmount > 0n,
     },
   });
 
@@ -111,18 +131,18 @@ export function useLeverageQuote({
       collateralTokenAddress,
       collateralTokenDecimals,
       swapExecutionAddress,
-      targetFlashCollateralAmount.toString(),
+      targetFlashCollateralTokenAmount.toString(),
       slippageBps,
       userAddress ?? null,
     ],
-    enabled: route?.kind === 'swap' && !isLoanAssetInput && targetFlashCollateralAmount > 0n && !!userAddress,
+    enabled: route?.kind === 'swap' && !isLoanAssetInput && targetFlashCollateralTokenAmount > 0n && !!userAddress,
     queryFn: async () => {
       const buyRoute = await fetchVeloraPriceRoute({
         srcToken: loanTokenAddress,
         srcDecimals: loanTokenDecimals,
         destToken: collateralTokenAddress,
         destDecimals: collateralTokenDecimals,
-        amount: targetFlashCollateralAmount,
+        amount: targetFlashCollateralTokenAmount,
         network: chainId,
         userAddress: swapExecutionAddress as `0x${string}`,
         side: 'BUY',
@@ -131,8 +151,8 @@ export function useLeverageQuote({
       const borrowAssets = BigInt(buyRoute.srcAmount);
       if (borrowAssets <= 0n) {
         return {
-          flashLoanAmount: 0n,
-          flashCollateralAmount: 0n,
+          flashLoanAssetAmount: 0n,
+          flashLegCollateralTokenAmount: 0n,
           priceRoute: null,
         };
       }
@@ -152,8 +172,8 @@ export function useLeverageQuote({
       }
 
       return {
-        flashLoanAmount: borrowAssets,
-        flashCollateralAmount: withSlippageFloor(BigInt(sellRoute.destAmount), slippageBps),
+        flashLoanAssetAmount: borrowAssets,
+        flashLegCollateralTokenAmount: withSlippageFloor(BigInt(sellRoute.destAmount), slippageBps),
         priceRoute: sellRoute,
       };
     },
@@ -170,24 +190,24 @@ export function useLeverageQuote({
       collateralTokenAddress,
       collateralTokenDecimals,
       swapExecutionAddress,
-      userInputAmount.toString(),
+      initialCapitalInputAmount.toString(),
       multiplierBps.toString(),
       slippageBps,
       userAddress ?? null,
     ],
-    enabled: route?.kind === 'swap' && isLoanAssetInput && userInputAmount > 0n && !!userAddress,
+    enabled: route?.kind === 'swap' && isLoanAssetInput && initialCapitalInputAmount > 0n && !!userAddress,
     queryFn: async () => {
-      const flashLoanAmount = computeLeveragedExtraAmount(userInputAmount, multiplierBps);
-      if (flashLoanAmount <= 0n) {
+      const flashLoanAssetAmount = computeLeveragedExtraAmount(initialCapitalInputAmount, multiplierBps);
+      if (flashLoanAssetAmount <= 0n) {
         return {
-          flashLoanAmount: 0n,
-          flashCollateralAmount: 0n,
-          totalAddedCollateral: 0n,
+          flashLoanAssetAmount: 0n,
+          flashLegCollateralTokenAmount: 0n,
+          totalCollateralTokenAmountAdded: 0n,
           priceRoute: null,
         };
       }
 
-      const totalLoanSellAmount = userInputAmount + flashLoanAmount;
+      const totalLoanSellAmount = initialCapitalInputAmount + flashLoanAssetAmount;
       const sellRoute = await fetchVeloraPriceRoute({
         srcToken: loanTokenAddress,
         srcDecimals: loanTokenDecimals,
@@ -202,57 +222,63 @@ export function useLeverageQuote({
         throw new Error('Failed to quote stable Velora swap route for leverage.');
       }
 
-      const totalAddedCollateral = withSlippageFloor(BigInt(sellRoute.destAmount), slippageBps);
+      const totalCollateralTokenAmountAdded = withSlippageFloor(BigInt(sellRoute.destAmount), slippageBps);
 
       return {
-        flashLoanAmount,
-        flashCollateralAmount: 0n,
-        totalAddedCollateral,
+        flashLoanAssetAmount,
+        flashLegCollateralTokenAmount: 0n,
+        totalCollateralTokenAmountAdded,
         priceRoute: sellRoute,
       };
     },
   });
 
-  const flashCollateralAmount = useMemo(() => {
+  const flashLegCollateralTokenAmount = useMemo(() => {
     if (!route) return 0n;
     if (route.kind === 'swap') {
-      if (isLoanAssetInput) return swapLoanInputCombinedQuoteQuery.data?.flashCollateralAmount ?? 0n;
-      return swapCollateralInputQuoteQuery.data?.flashCollateralAmount ?? 0n;
+      if (isLoanAssetInput) return swapLoanInputCombinedQuoteQuery.data?.flashLegCollateralTokenAmount ?? 0n;
+      return swapCollateralInputQuoteQuery.data?.flashLegCollateralTokenAmount ?? 0n;
     }
-    return targetFlashCollateralAmount;
+    return targetFlashCollateralTokenAmount;
   }, [
     route,
     isLoanAssetInput,
-    targetFlashCollateralAmount,
-    swapLoanInputCombinedQuoteQuery.data?.flashCollateralAmount,
-    swapCollateralInputQuoteQuery.data?.flashCollateralAmount,
+    targetFlashCollateralTokenAmount,
+    swapLoanInputCombinedQuoteQuery.data?.flashLegCollateralTokenAmount,
+    swapCollateralInputQuoteQuery.data?.flashLegCollateralTokenAmount,
   ]);
 
-  const flashLoanAmount = useMemo(() => {
+  const flashLoanAssetAmount = useMemo(() => {
     if (!route) return 0n;
     if (route.kind === 'swap') {
-      if (isLoanAssetInput) return swapLoanInputCombinedQuoteQuery.data?.flashLoanAmount ?? 0n;
-      return swapCollateralInputQuoteQuery.data?.flashLoanAmount ?? 0n;
+      if (isLoanAssetInput) return swapLoanInputCombinedQuoteQuery.data?.flashLoanAssetAmount ?? 0n;
+      return swapCollateralInputQuoteQuery.data?.flashLoanAssetAmount ?? 0n;
     }
-    // `previewMint(targetFlashCollateralAmount)` returns how many loan-token assets the flash leg
+    // `previewMint(targetFlashCollateralTokenAmount)` returns how many loan-token assets the flash leg
     // must source to mint that exact collateral-share amount.
     return (previewMintRequiredLoanAssetsForFlashCollateralShares as bigint | undefined) ?? 0n;
   }, [
     route,
     isLoanAssetInput,
-    swapLoanInputCombinedQuoteQuery.data?.flashLoanAmount,
-    swapCollateralInputQuoteQuery.data?.flashLoanAmount,
+    swapLoanInputCombinedQuoteQuery.data?.flashLoanAssetAmount,
+    swapCollateralInputQuoteQuery.data?.flashLoanAssetAmount,
     previewMintRequiredLoanAssetsForFlashCollateralShares,
   ]);
 
-  const totalAddedCollateral = useMemo(() => {
+  const totalCollateralTokenAmountAdded = useMemo(() => {
     if (!route) return 0n;
     if (route.kind === 'swap') {
-      if (isLoanAssetInput) return swapLoanInputCombinedQuoteQuery.data?.totalAddedCollateral ?? 0n;
-      return initialCollateralAmount + flashCollateralAmount;
+      if (isLoanAssetInput) return swapLoanInputCombinedQuoteQuery.data?.totalCollateralTokenAmountAdded ?? 0n;
+      return initialCapitalCollateralTokenAmount + flashLegCollateralTokenAmount;
     }
-    return initialCollateralAmount + flashCollateralAmount;
-  }, [route, isLoanAssetInput, initialCollateralAmount, flashCollateralAmount, swapLoanInputCombinedQuoteQuery.data?.totalAddedCollateral]);
+    return initialCapitalCollateralTokenAmount + flashLegCollateralTokenAmount;
+  }, [
+    route,
+    isLoanAssetInput,
+    initialCapitalCollateralTokenAmount,
+    flashLegCollateralTokenAmount,
+    swapLoanInputCombinedQuoteQuery.data?.totalCollateralTokenAmountAdded,
+  ]);
 
   const swapPriceRoute = useMemo(() => {
     if (route?.kind !== 'swap') return null;
@@ -263,7 +289,7 @@ export function useLeverageQuote({
   const error = useMemo(() => {
     if (!route) return null;
     if (route.kind === 'swap') {
-      if (!userAddress && userInputAmount > 0n) return 'Connect wallet to fetch swap-backed leverage route.';
+      if (!userAddress && initialCapitalInputAmount > 0n) return 'Connect wallet to fetch swap-backed leverage route.';
       const routeError = isLoanAssetInput ? swapLoanInputCombinedQuoteQuery.error : swapCollateralInputQuoteQuery.error;
       if (!routeError) return null;
       return routeError instanceof Error ? routeError.message : 'Failed to quote Velora swap route for leverage.';
@@ -275,7 +301,7 @@ export function useLeverageQuote({
     route,
     swapExecutionAddress,
     userAddress,
-    userInputAmount,
+    initialCapitalInputAmount,
     isLoanAssetInput,
     swapLoanInputCombinedQuoteQuery.error,
     swapCollateralInputQuoteQuery.error,
@@ -291,10 +317,10 @@ export function useLeverageQuote({
       : isLoadingErc4626Deposit || isLoadingErc4626Mint);
 
   return {
-    initialCollateralAmount,
-    flashCollateralAmount,
-    flashLoanAmount,
-    totalAddedCollateral,
+    initialCapitalCollateralTokenAmount,
+    flashLegCollateralTokenAmount,
+    flashLoanAssetAmount,
+    totalCollateralTokenAmountAdded,
     isLoading,
     error,
     swapPriceRoute,
diff --git a/src/hooks/useLeverageTransaction.ts b/src/hooks/useLeverageTransaction.ts
index bb7df949..9cbb788f 100644
--- a/src/hooks/useLeverageTransaction.ts
+++ b/src/hooks/useLeverageTransaction.ts
@@ -25,15 +25,20 @@ export type { LeverageStepType } from '@/hooks/leverage/transaction-shared';
 type UseLeverageTransactionProps = {
   market: Market;
   route: LeverageRoute | null;
-  collateralAmount: bigint;
-  collateralAmountInCollateralToken: bigint;
-  flashCollateralAmount: bigint;
-  flashLoanAmount: bigint;
-  totalAddedCollateral: bigint;
+  /** Exact user-entered starting capital, denominated by `useLoanAssetInput`. */
+  initialCapitalInputAmount: bigint;
+  /** Market collateral-token amount sourced from the initial capital before the flash leg. */
+  initialCapitalCollateralTokenAmount: bigint;
+  /** Market collateral-token amount added by the flash leg. */
+  flashLegCollateralTokenAmount: bigint;
+  /** Flash-loaned market loan-asset amount. */
+  flashLoanAssetAmount: bigint;
+  /** Total market collateral-token amount added before leverage fee. */
+  totalCollateralTokenAmountAdded: bigint;
   collateralAssetPriceUsd: number | null;
   swapPriceRoute: VeloraPriceRoute | null;
   slippageBps: number;
-  useLoanAssetAsInput: boolean;
+  useLoanAssetInput: boolean;
   onSuccess?: () => void;
 };
 
@@ -59,15 +64,15 @@ type LeverageExecutionPreflight =
 export function useLeverageTransaction({
   market,
   route,
-  collateralAmount,
-  collateralAmountInCollateralToken,
-  flashCollateralAmount,
-  flashLoanAmount,
-  totalAddedCollateral,
+  initialCapitalInputAmount,
+  initialCapitalCollateralTokenAmount,
+  flashLegCollateralTokenAmount,
+  flashLoanAssetAmount,
+  totalCollateralTokenAmountAdded,
   collateralAssetPriceUsd,
   swapPriceRoute,
   slippageBps,
-  useLoanAssetAsInput,
+  useLoanAssetInput,
   onSuccess,
 }: UseLeverageTransactionProps) {
   const { usePermit2: usePermit2Setting } = useAppSettings();
@@ -93,11 +98,13 @@ export function useLeverageTransaction({
   }, [route, bundlerAddress]);
 
   const { batchAddUserMarkets } = useUserMarketsCache(account);
-  const isLoanAssetInput = useLoanAssetAsInput;
-  const inputTokenAddress = isLoanAssetInput ? (market.loanAsset.address as Address) : (market.collateralAsset.address as Address);
-  const inputTokenSymbol = isLoanAssetInput ? market.loanAsset.symbol : market.collateralAsset.symbol;
-  const inputTokenDecimals = isLoanAssetInput ? market.loanAsset.decimals : market.collateralAsset.decimals;
-  const inputTokenAmountForTransfer = isLoanAssetInput ? collateralAmount : collateralAmountInCollateralToken;
+  const initialCapitalUsesLoanAsset = useLoanAssetInput;
+  const initialCapitalInputTokenAddress = initialCapitalUsesLoanAsset
+    ? (market.loanAsset.address as Address)
+    : (market.collateralAsset.address as Address);
+  const initialCapitalInputTokenSymbol = initialCapitalUsesLoanAsset ? market.loanAsset.symbol : market.collateralAsset.symbol;
+  const initialCapitalInputTokenDecimals = initialCapitalUsesLoanAsset ? market.loanAsset.decimals : market.collateralAsset.decimals;
+  const initialCapitalTransferAmount = initialCapitalUsesLoanAsset ? initialCapitalInputAmount : initialCapitalCollateralTokenAmount;
   const approvalSpender = route?.kind === 'swap' ? route.generalAdapterAddress : bundlerAddress;
 
   const {
@@ -120,25 +127,25 @@ export function useLeverageTransaction({
   } = usePermit2({
     user: account as `0x${string}`,
     spender: approvalSpender,
-    token: inputTokenAddress as `0x${string}`,
+    token: initialCapitalInputTokenAddress as `0x${string}`,
     refetchInterval: 10_000,
     chainId: market.morphoBlue.chain.id,
-    tokenSymbol: inputTokenSymbol,
-    amount: usePermit2ForRoute ? inputTokenAmountForTransfer : 0n,
+    tokenSymbol: initialCapitalInputTokenSymbol,
+    amount: usePermit2ForRoute ? initialCapitalTransferAmount : 0n,
   });
   const isAuthorizationReadyForRoute = usePermit2ForRoute ? isBundlerAuthorizationReady : isBundlerAuthorizationStatusReady;
 
   const { isApproved, approve, isApproving } = useERC20Approval({
-    token: inputTokenAddress,
+    token: initialCapitalInputTokenAddress,
     spender: approvalSpender,
-    amount: inputTokenAmountForTransfer,
-    tokenSymbol: inputTokenSymbol,
+    amount: initialCapitalTransferAmount,
+    tokenSymbol: initialCapitalInputTokenSymbol,
     chainId: market.morphoBlue.chain.id,
   });
 
   const { isConfirming: leveragePending, sendTransactionAsync } = useTransactionWithToast({
     toastId: 'leverage',
-    pendingText: `Leveraging ${formatBalance(collateralAmount, inputTokenDecimals)} ${inputTokenSymbol}`,
+    pendingText: `Leveraging ${formatBalance(initialCapitalInputAmount, initialCapitalInputTokenDecimals)} ${initialCapitalInputTokenSymbol}`,
     successText: 'Leverage Executed',
     errorText: 'Failed to execute leverage',
     chainId,
@@ -153,11 +160,11 @@ export function useLeverageTransaction({
     () => ({
       title: 'Leverage',
       description: `${market.collateralAsset.symbol} leveraged using ${market.loanAsset.symbol} debt`,
-      tokenSymbol: inputTokenSymbol,
-      amount: collateralAmount,
+      tokenSymbol: initialCapitalInputTokenSymbol,
+      amount: initialCapitalInputAmount,
       marketId: market.uniqueKey,
     }),
-    [market.collateralAsset.symbol, market.loanAsset.symbol, inputTokenSymbol, collateralAmount, market.uniqueKey],
+    [market.collateralAsset.symbol, market.loanAsset.symbol, initialCapitalInputTokenSymbol, initialCapitalInputAmount, market.uniqueKey],
   );
 
   const getStepsForFlow = useCallback(
@@ -196,8 +203,8 @@ export function useLeverageTransaction({
           },
           {
             id: 'approve_token',
-            title: `Approve ${inputTokenSymbol}`,
-            description: `Approve ${inputTokenSymbol} transfer for the leverage flow.`,
+            title: `Approve ${initialCapitalInputTokenSymbol}`,
+            description: `Approve ${initialCapitalInputTokenSymbol} transfer for the leverage flow.`,
           },
           {
             id: 'execute',
@@ -222,7 +229,7 @@ export function useLeverageTransaction({
           {
             id: 'sign_permit',
             title: 'Sign Token Permit',
-            description: 'Sign Permit2 transfer authorization for collateral transfer.',
+            description: `Sign Permit2 transfer authorization for ${initialCapitalInputTokenSymbol}.`,
           },
           {
             id: 'execute',
@@ -240,8 +247,8 @@ export function useLeverageTransaction({
         },
         {
           id: 'approve_token',
-          title: `Approve ${inputTokenSymbol}`,
-          description: `Approve ${inputTokenSymbol} transfer for the leverage flow.`,
+          title: `Approve ${initialCapitalInputTokenSymbol}`,
+          description: `Approve ${initialCapitalInputTokenSymbol} transfer for the leverage flow.`,
         },
         {
           id: 'execute',
@@ -250,7 +257,7 @@ export function useLeverageTransaction({
         },
       ];
     },
-    [inputTokenSymbol],
+    [initialCapitalInputTokenSymbol],
   );
 
   const getLeverageExecutionPreflight = useCallback((): LeverageExecutionPreflight | null => {
@@ -264,9 +271,10 @@ export function useLeverageTransaction({
       return null;
     }
 
-    const hasCollateralOutput = route.kind === 'swap' && isLoanAssetInput ? totalAddedCollateral > 0n : flashCollateralAmount > 0n;
-    if (collateralAmount <= 0n || flashLoanAmount <= 0n || !hasCollateralOutput) {
-      toast.info('Invalid leverage inputs', 'Set collateral and multiplier above 1x before submitting.');
+    const hasCollateralOutput =
+      route.kind === 'swap' && initialCapitalUsesLoanAsset ? totalCollateralTokenAmountAdded > 0n : flashLegCollateralTokenAmount > 0n;
+    if (initialCapitalInputAmount <= 0n || flashLoanAssetAmount <= 0n || !hasCollateralOutput) {
+      toast.info('Invalid leverage inputs', 'Set initial capital and multiplier above 1x before submitting.');
       return null;
     }
     if (collateralAssetPriceUsd == null || !Number.isFinite(collateralAssetPriceUsd) || collateralAssetPriceUsd <= 0) {
@@ -275,11 +283,11 @@ export function useLeverageTransaction({
     }
 
     const leverageFeeAmount = getLeverageFee({
-      amount: totalAddedCollateral,
+      amount: totalCollateralTokenAmountAdded,
       assetPriceUsd: collateralAssetPriceUsd,
       assetDecimals: market.collateralAsset.decimals,
     });
-    if (totalAddedCollateral - leverageFeeAmount <= 0n) {
+    if (totalCollateralTokenAmountAdded - leverageFeeAmount <= 0n) {
       toast.info('Leverage unavailable', 'Net collateral after fee must be positive.');
       return null;
     }
@@ -307,11 +315,11 @@ export function useLeverageTransaction({
   }, [
     account,
     route,
-    isLoanAssetInput,
-    totalAddedCollateral,
-    flashCollateralAmount,
-    collateralAmount,
-    flashLoanAmount,
+    initialCapitalUsesLoanAsset,
+    totalCollateralTokenAmountAdded,
+    flashLegCollateralTokenAmount,
+    initialCapitalInputAmount,
+    flashLoanAssetAmount,
     collateralAssetPriceUsd,
     market.collateralAsset.decimals,
     swapPriceRoute,
@@ -338,12 +346,12 @@ export function useLeverageTransaction({
           market,
           marketParams,
           route: execution.route,
-          inputTokenAddress,
-          inputTokenAmountForTransfer,
-          isLoanAssetInput,
-          flashLoanAmount,
-          flashCollateralAmount,
-          totalAddedCollateral,
+          initialCapitalInputTokenAddress,
+          initialCapitalTransferAmount,
+          isLoanAssetInput: initialCapitalUsesLoanAsset,
+          flashLoanAssetAmount,
+          flashLegCollateralTokenAmount,
+          totalCollateralTokenAmountAdded,
           leverageFeeAmount: execution.leverageFeeAmount,
           swapPriceRoute: swapExecutionPriceRoute,
           slippageBps,
@@ -365,13 +373,13 @@ export function useLeverageTransaction({
           market,
           marketParams,
           route: execution.route,
-          collateralAmount,
-          collateralAmountInCollateralToken,
-          inputTokenAddress,
-          inputTokenAmountForTransfer,
-          isLoanAssetInput,
-          flashCollateralAmount,
-          flashLoanAmount,
+          initialCapitalInputAmount,
+          initialCapitalCollateralTokenAmount,
+          initialCapitalInputTokenAddress,
+          initialCapitalTransferAmount,
+          isLoanAssetInput: initialCapitalUsesLoanAsset,
+          flashLegCollateralTokenAmount,
+          flashLoanAssetAmount,
           leverageFeeAmount: execution.leverageFeeAmount,
           usePermit2: usePermit2ForRoute,
           permit2Authorized,
@@ -389,14 +397,14 @@ export function useLeverageTransaction({
     [
       market,
       bundlerAddress,
-      collateralAmount,
-      collateralAmountInCollateralToken,
-      inputTokenAddress,
-      inputTokenAmountForTransfer,
-      isLoanAssetInput,
-      flashLoanAmount,
-      flashCollateralAmount,
-      totalAddedCollateral,
+      initialCapitalInputAmount,
+      initialCapitalCollateralTokenAmount,
+      initialCapitalInputTokenAddress,
+      initialCapitalTransferAmount,
+      initialCapitalUsesLoanAsset,
+      flashLoanAssetAmount,
+      flashLegCollateralTokenAmount,
+      totalCollateralTokenAmountAdded,
       slippageBps,
       usePermit2ForRoute,
       permit2Authorized,
diff --git a/src/modals/leverage/components/add-collateral-and-leverage.tsx b/src/modals/leverage/components/add-collateral-and-leverage.tsx
index 0a2100c2..a3dfca08 100644
--- a/src/modals/leverage/components/add-collateral-and-leverage.tsx
+++ b/src/modals/leverage/components/add-collateral-and-leverage.tsx
@@ -81,8 +81,8 @@ export function AddCollateralAndLeverage({
     [defaultMultiplierBps, maxTargetLtvBps],
   );
 
-  const [collateralAmount, setCollateralAmount] = useState<bigint>(0n);
-  const [collateralInputError, setCollateralInputError] = useState<string | null>(null);
+  const [initialCapitalInputAmount, setInitialCapitalInputAmount] = useState<bigint>(0n);
+  const [initialCapitalInputError, setInitialCapitalInputError] = useState<string | null>(null);
   const [useLoanAssetInput, setUseLoanAssetInput] = useState(false);
   const [targetMultiplierBps, setTargetMultiplierBps] = useState<bigint>(defaultMultiplierBps);
   const [targetLtvIntentBps, setTargetLtvIntentBps] = useState<bigint>(defaultTargetLtvIntentBps);
@@ -110,9 +110,9 @@ export function AddCollateralAndLeverage({
   });
 
   useEffect(() => {
-    // Underlying and collateral shares use different units. Reset amount when switching input source.
-    setCollateralAmount(0n);
-    setCollateralInputError(null);
+    // The initial-capital field flips between loan-asset units and collateral-token units.
+    setInitialCapitalInputAmount(0n);
+    setInitialCapitalInputError(null);
   }, [useLoanAssetInput]);
 
   useEffect(() => {
@@ -136,7 +136,7 @@ export function AddCollateralAndLeverage({
   const quote = useLeverageQuote({
     chainId: market.morphoBlue.chain.id,
     route,
-    userInputAmount: collateralAmount,
+    initialCapitalInputAmount,
     inputMode: useLoanAssetInput ? 'loan' : 'collateral',
     multiplierBps,
     loanTokenAddress: market.loanAsset.address,
@@ -149,7 +149,7 @@ export function AddCollateralAndLeverage({
 
   const currentCollateralAssets = BigInt(currentPosition?.state.collateral ?? 0);
   const currentBorrowAssets = BigInt(currentPosition?.state.borrowAssets ?? 0);
-  const hasQuoteChanges = quote.totalAddedCollateral > 0n && quote.flashLoanAmount > 0n;
+  const hasQuoteChanges = quote.totalCollateralTokenAmountAdded > 0n && quote.flashLoanAssetAmount > 0n;
   const collateralAssetPriceUsd = useMemo(() => {
     const totalCollateralAssets = BigInt(market.state.collateralAssets);
     const totalCollateralAssetsUsd = market.state.collateralAssetsUsd;
@@ -171,15 +171,15 @@ export function AddCollateralAndLeverage({
   const leverageTransferFee = useMemo<bigint | null>(() => {
     if (collateralAssetPriceUsd == null) return null;
     return getLeverageFee({
-      amount: quote.totalAddedCollateral,
+      amount: quote.totalCollateralTokenAmountAdded,
       assetPriceUsd: collateralAssetPriceUsd,
       assetDecimals: market.collateralAsset.decimals,
     });
-  }, [quote.totalAddedCollateral, collateralAssetPriceUsd, market.collateralAsset.decimals]);
+  }, [quote.totalCollateralTokenAmountAdded, collateralAssetPriceUsd, market.collateralAsset.decimals]);
   const netAddedCollateral = useMemo<bigint | null>(() => {
     if (leverageTransferFee == null) return null;
-    return quote.totalAddedCollateral - leverageTransferFee;
-  }, [quote.totalAddedCollateral, leverageTransferFee]);
+    return quote.totalCollateralTokenAmountAdded - leverageTransferFee;
+  }, [quote.totalCollateralTokenAmountAdded, leverageTransferFee]);
   const isLeverageFeeReady = useMemo(
     () => hasQuoteChanges && leverageTransferFee != null && netAddedCollateral != null && netAddedCollateral > 0n,
     [hasQuoteChanges, leverageTransferFee, netAddedCollateral],
@@ -195,7 +195,10 @@ export function AddCollateralAndLeverage({
     () => (isLeverageFeeReady && netAddedCollateral != null ? netAddedCollateral : 0n),
     [isLeverageFeeReady, netAddedCollateral],
   );
-  const addedBorrowAssets = useMemo(() => (isLeverageFeeReady ? quote.flashLoanAmount : 0n), [isLeverageFeeReady, quote.flashLoanAmount]);
+  const addedBorrowAssets = useMemo(
+    () => (isLeverageFeeReady ? quote.flashLoanAssetAmount : 0n),
+    [isLeverageFeeReady, quote.flashLoanAssetAmount],
+  );
   const { projectedCollateralAssets, projectedBorrowAssets } = useMemo(
     () =>
       computeLeverageProjectedPosition({
@@ -255,8 +258,8 @@ export function AddCollateralAndLeverage({
 
   const handleTransactionSuccess = useCallback(() => {
     // WHY: after a confirmed leverage tx, reset drafts so the panel reflects refreshed onchain position state.
-    setCollateralAmount(0n);
-    setCollateralInputError(null);
+    setInitialCapitalInputAmount(0n);
+    setInitialCapitalInputError(null);
     syncInputFieldsFromMultiplier(defaultMultiplierBps);
     if (useLoanAssetInput) {
       void refetchLoanTokenBalance();
@@ -275,14 +278,14 @@ export function AddCollateralAndLeverage({
   } = useLeverageTransaction({
     market,
     route,
-    collateralAmount,
-    collateralAmountInCollateralToken: quote.initialCollateralAmount,
-    flashCollateralAmount: quote.flashCollateralAmount,
-    flashLoanAmount: quote.flashLoanAmount,
-    totalAddedCollateral: quote.totalAddedCollateral,
+    initialCapitalInputAmount,
+    initialCapitalCollateralTokenAmount: quote.initialCapitalCollateralTokenAmount,
+    flashLegCollateralTokenAmount: quote.flashLegCollateralTokenAmount,
+    flashLoanAssetAmount: quote.flashLoanAssetAmount,
+    totalCollateralTokenAmountAdded: quote.totalCollateralTokenAmountAdded,
     collateralAssetPriceUsd,
     swapPriceRoute: quote.swapPriceRoute,
-    useLoanAssetAsInput: useLoanAssetInput,
+    useLoanAssetInput,
     slippageBps: swapSlippageBps,
     onSuccess: handleTransactionSuccess,
   });
@@ -311,18 +314,18 @@ export function AddCollateralAndLeverage({
   }, [isLeverageFeeReady, usePermit2Setting, permit2Authorized, signAndLeverage, approveAndLeverage]);
 
   const projectedOverLimit = projectedLTV >= lltv;
-  const insufficientLiquidity = quote.flashLoanAmount > marketLiquidity;
+  const insufficientLiquidity = quote.flashLoanAssetAmount > marketLiquidity;
   const inputAssetSymbol = useLoanAssetInput ? market.loanAsset.symbol : market.collateralAsset.symbol;
   const inputAssetDecimals = useLoanAssetInput ? market.loanAsset.decimals : market.collateralAsset.decimals;
   const inputAssetBalance = useLoanAssetInput ? (loanTokenBalance as bigint | undefined) : collateralTokenBalance;
   const inputTokenIconAddress = useLoanAssetInput ? market.loanAsset.address : market.collateralAsset.address;
   const flashBorrowPreview = useMemo(
-    () => formatTokenAmountPreview(quote.flashLoanAmount, market.loanAsset.decimals),
-    [quote.flashLoanAmount, market.loanAsset.decimals],
+    () => formatTokenAmountPreview(quote.flashLoanAssetAmount, market.loanAsset.decimals),
+    [quote.flashLoanAssetAmount, market.loanAsset.decimals],
   );
   const totalCollateralAddedPreview = useMemo(
-    () => formatTokenAmountPreview(quote.totalAddedCollateral, market.collateralAsset.decimals),
-    [quote.totalAddedCollateral, market.collateralAsset.decimals],
+    () => formatTokenAmountPreview(quote.totalCollateralTokenAmountAdded, market.collateralAsset.decimals),
+    [quote.totalCollateralTokenAmountAdded, market.collateralAsset.decimals],
   );
   const leverageFeePreview = useMemo(() => {
     if (!isLeverageFeeReady || leverageTransferFee == null) return null;
@@ -345,8 +348,8 @@ export function AddCollateralAndLeverage({
     }).format(feeUsdValue);
   }, [isLeverageFeeReady, leverageTransferFee, collateralAssetPriceUsd, market.collateralAsset.decimals]);
   const swapCollateralOutPreview = useMemo(
-    () => formatTokenAmountPreview(quote.flashCollateralAmount, market.collateralAsset.decimals),
-    [quote.flashCollateralAmount, market.collateralAsset.decimals],
+    () => formatTokenAmountPreview(quote.flashLegCollateralTokenAmount, market.collateralAsset.decimals),
+    [quote.flashLegCollateralTokenAmount, market.collateralAsset.decimals],
   );
   const collateralPreviewForDisplay = isSwapRoute && !useLoanAssetInput ? swapCollateralOutPreview : totalCollateralAddedPreview;
   const collateralPreviewLabel = isSwapRoute
@@ -354,12 +357,12 @@ export function AddCollateralAndLeverage({
       ? 'Total Collateral Added (Min.)'
       : 'Collateral From Swap (Min.)'
     : 'Total Collateral Added';
-  const hasExecutableInputConversion = useMemo(() => {
+  const hasExecutableInitialCapitalConversion = useMemo(() => {
     if (!useLoanAssetInput) return true;
-    if (isSwapRoute) return quote.totalAddedCollateral > 0n;
-    if (isErc4626Route) return quote.initialCollateralAmount > 0n;
+    if (isSwapRoute) return quote.totalCollateralTokenAmountAdded > 0n;
+    if (isErc4626Route) return quote.initialCapitalCollateralTokenAmount > 0n;
     return false;
-  }, [useLoanAssetInput, isSwapRoute, isErc4626Route, quote.totalAddedCollateral, quote.initialCollateralAmount]);
+  }, [useLoanAssetInput, isSwapRoute, isErc4626Route, quote.totalCollateralTokenAmountAdded, quote.initialCapitalCollateralTokenAmount]);
   const swapRatePreviewText = useMemo(() => {
     if (!isSwapRoute || !quote.swapPriceRoute) return null;
 
@@ -416,9 +419,9 @@ export function AddCollateralAndLeverage({
   }, [isErc4626Route, vaultRateInsight.borrowApy3d, market.state.borrowApy]);
   const projectedBorrowApy = useMemo(() => {
     if (!hasChanges) return null;
-    const preview = previewMarketState(market, undefined, quote.flashLoanAmount);
+    const preview = previewMarketState(market, undefined, quote.flashLoanAssetAmount);
     return preview?.borrowApy ?? null;
-  }, [hasChanges, market, quote.flashLoanAmount]);
+  }, [hasChanges, market, quote.flashLoanAssetAmount]);
   const previewBorrowApy = projectedBorrowApy ?? fallbackBorrowApy;
   const borrowRatePreviewLabel = projectedBorrowApy != null ? `Borrow ${rateLabel} (Est.)` : `Borrow ${rateLabel}`;
   const vaultTokenApy = isErc4626Route ? vaultRateInsight.vaultApy3d : 0;
@@ -495,24 +498,25 @@ export function AddCollateralAndLeverage({
     if (addedCollateralAssets <= 0n) return null;
 
     if (isSwapRoute && useLoanAssetInput) {
-      const totalLoanInput = collateralAmount + addedBorrowAssets;
+      const totalLoanInput = initialCapitalInputAmount + addedBorrowAssets;
       if (totalLoanInput <= 0n) return null;
 
-      const contributedFromLoanInput = (addedCollateralAssets * collateralAmount) / totalLoanInput;
+      const contributedFromLoanInput = (addedCollateralAssets * initialCapitalInputAmount) / totalLoanInput;
       return contributedFromLoanInput > 0n ? contributedFromLoanInput : null;
     }
 
-    if (quote.totalAddedCollateral <= 0n || quote.initialCollateralAmount <= 0n) return null;
+    if (quote.totalCollateralTokenAmountAdded <= 0n || quote.initialCapitalCollateralTokenAmount <= 0n) return null;
 
-    const contributedFromInitialCollateral = (addedCollateralAssets * quote.initialCollateralAmount) / quote.totalAddedCollateral;
+    const contributedFromInitialCollateral =
+      (addedCollateralAssets * quote.initialCapitalCollateralTokenAmount) / quote.totalCollateralTokenAmountAdded;
     return contributedFromInitialCollateral > 0n ? contributedFromInitialCollateral : null;
   }, [
     addedBorrowAssets,
     addedCollateralAssets,
-    collateralAmount,
+    initialCapitalInputAmount,
     isSwapRoute,
-    quote.initialCollateralAmount,
-    quote.totalAddedCollateral,
+    quote.initialCapitalCollateralTokenAmount,
+    quote.totalCollateralTokenAmountAdded,
     useLoanAssetInput,
   ]);
   const holdRewardsApy = useMemo(() => {
@@ -616,9 +620,7 @@ export function AddCollateralAndLeverage({
           <div className="mt-2 space-y-3">
             <div className="rounded border border-white/10 bg-hovered px-3 py-2.5">
               <div className="mb-1 flex items-center justify-between gap-2">
-                <p className="text-[11px] uppercase tracking-[0.12em] text-secondary">
-                  {useLoanAssetInput ? `Start with ${market.loanAsset.symbol}` : `Add Collateral ${market.collateralAsset.symbol}`}
-                </p>
+                <p className="text-[11px] uppercase tracking-[0.12em] text-secondary">Initial Capital</p>
                 {canUseLoanAssetInput && (
                   <div className="flex items-center gap-2">
                     <div className="text-xs text-secondary">Use {market.loanAsset.symbol}</div>
@@ -635,13 +637,18 @@ export function AddCollateralAndLeverage({
                   </div>
                 )}
               </div>
+              <p className="mb-2 text-xs text-secondary">
+                {useLoanAssetInput
+                  ? `Enter the ${market.loanAsset.symbol} you want to start with. It will be converted into ${market.collateralAsset.symbol} during the leverage flow.`
+                  : `Enter the ${market.collateralAsset.symbol} you want to contribute before the flash leg.`}
+              </p>
               <Input
                 decimals={inputAssetDecimals}
                 max={inputAssetBalance}
-                setValue={setCollateralAmount}
-                setError={setCollateralInputError}
+                setValue={setInitialCapitalInputAmount}
+                setError={setInitialCapitalInputError}
                 exceedMaxErrMessage="Insufficient Balance"
-                value={collateralAmount}
+                value={initialCapitalInputAmount}
                 inputClassName="h-10 rounded bg-surface px-3 py-2 text-base font-medium tabular-nums"
                 endAdornment={
                   <TokenIcon
@@ -654,7 +661,7 @@ export function AddCollateralAndLeverage({
                 }
               />
               <div className="mt-1 flex items-start gap-3 text-xs">
-                {collateralInputError && <p className="text-red-500">{collateralInputError}</p>}
+                {initialCapitalInputError && <p className="text-red-500">{initialCapitalInputError}</p>}
                 <span className="ml-auto text-right text-secondary">
                   Balance: {formatBalance(inputAssetBalance ?? 0n, inputAssetDecimals)} {inputAssetSymbol}
                 </span>
@@ -877,13 +884,13 @@ export function AddCollateralAndLeverage({
                 isLoading={isLoadingPermit2 || leveragePending || quote.isLoading}
                 disabled={
                   route == null ||
-                  collateralInputError !== null ||
+                  initialCapitalInputError !== null ||
                   quote.error !== null ||
-                  collateralAmount <= 0n ||
+                  initialCapitalInputAmount <= 0n ||
                   !isBundlerAuthorizationReady ||
-                  !hasExecutableInputConversion ||
+                  !hasExecutableInitialCapitalConversion ||
                   !isLeverageFeeReady ||
-                  quote.flashLoanAmount <= 0n ||
+                  quote.flashLoanAssetAmount <= 0n ||
                   projectedOverLimit ||
                   insufficientLiquidity
                 }

From f84a998550ec31e1cf9d93a8feee102a197ce899 Mon Sep 17 00:00:00 2001
From: antoncoding <antonassocareer@gmail.com>
Date: Sun, 8 Mar 2026 20:04:27 +0800
Subject: [PATCH 5/5] chore: cleanup

---
 AGENTS.md                                          |  9 +++++----
 src/features/swap/api/velora.ts                    | 13 +++++--------
 src/hooks/deleverage/deleverageWithSwap.ts         | 14 +++++++-------
 src/hooks/leverage/leverageWithSwap.ts             |  7 +------
 src/hooks/useDeleverageQuote.ts                    |  7 ++-----
 src/hooks/useLeverageQuote.ts                      |  8 ++------
 .../components/add-collateral-and-leverage.tsx     |  5 -----
 7 files changed, 22 insertions(+), 41 deletions(-)

diff --git a/AGENTS.md b/AGENTS.md
index 3bd2ffa5..eb3f13b3 100644
--- a/AGENTS.md
+++ b/AGENTS.md
@@ -156,10 +156,11 @@ When touching transaction and position flows, validation MUST include all releva
 21. **Modal UX integrity**: transaction-modal help/fee tooltips must render above modal layers via shared tooltip z-index chokepoints, and per-flow input mode toggles (for example target LTV vs amount) must persist through shared settings across modal reopen.
 22. **Chain-scoped identity integrity**: all market/token/route identity checks must be chain-scoped and use canonical identifiers (`chainId + market.uniqueKey` or `chainId + address`), including matching, dedupe keys, routing, and trust/allowlist gates.
 23. **Bundler residual-asset integrity**: any flash-loan transaction path that routes assets through Bundler/adapter balances (Bundler V2, GeneralAdapter, ParaswapAdapter) must end with explicit trailing sweeps of both loan and collateral tokens to the intended recipient across leverage/deleverage and swap/ERC4626 paths, and must keep execute-time slippage bounds consistent with quote-time slippage settings.
-24. **Deterministic flash-loan asset floors**: when a no-swap ERC4626 redeem/withdraw leg is the source of flash-loan repayment assets, its execute-time minimum asset bound must be at least the flash-loan settlement amount itself; do not apply swap-style slippage floors that allow the callback to under-return assets and fail only at final flash-loan settlement.
-25. **Deterministic ERC4626 quote/execution matching**: when a no-swap ERC4626 leverage leg uses vault previews, the execute-time operation must match the preview semantics exactly: `previewDeposit` should map to exact-asset deposit with the quoted share floor, and `previewMint` should map to exact-share mint with the quoted asset cap. Do not reuse swap-style slippage floors on either path.
-26. **Transaction-tracking preflight integrity**: do not call `tracking.start(...)` until all synchronous preflight validation for the flow has passed (account, route, quote, input, fee viability). Once tracking has started, execution helpers must either complete successfully or throw so the caller can finish the lifecycle with exactly one `tracking.complete()` or `tracking.fail()`.
-27. **Close-route collateral handoff integrity**: when a deleverage projection derives an exact close-bound collateral amount for full-repay-by-shares, route-specific executors must receive and use that quote-derived close bound explicitly for withdraw/redeem steps instead of relying on the raw user input amount. Any remaining collateral must be returned through the dedicated post-close withdraw/sweep path.
+24. **Swap execution-field integrity**: for Velora/Paraswap routes, hard preview and execution guards must validate execution-authoritative fields only (trusted target, exact sell amount, min-out / close floor, token identities). Do not block flows on echoed route metadata such as quoted source or quoted destination amounts when calldata checks already enforce the executable bounds.
+25. **Deterministic flash-loan asset floors**: when a no-swap ERC4626 redeem/withdraw leg is the source of flash-loan repayment assets, its execute-time minimum asset bound must be at least the flash-loan settlement amount itself; do not apply swap-style slippage floors that allow the callback to under-return assets and fail only at final flash-loan settlement.
+26. **Deterministic ERC4626 quote/execution matching**: when a no-swap ERC4626 leverage leg uses vault previews, the execute-time operation must match the preview semantics exactly: `previewDeposit` should map to exact-asset deposit with the quoted share floor, and `previewMint` should map to exact-share mint with the quoted asset cap. Do not reuse swap-style slippage floors on either path.
+27. **Transaction-tracking preflight integrity**: do not call `tracking.start(...)` until all synchronous preflight validation for the flow has passed (account, route, quote, input, fee viability). Once tracking has started, execution helpers must either complete successfully or throw so the caller can finish the lifecycle with exactly one `tracking.complete()` or `tracking.fail()`.
+28. **Close-route collateral handoff integrity**: when a deleverage projection derives an exact close-bound collateral amount for full-repay-by-shares, route-specific executors must receive and use that quote-derived close bound explicitly for withdraw/redeem steps instead of relying on the raw user input amount. Any remaining collateral must be returned through the dedicated post-close withdraw/sweep path.
 
 
 ### REQUIRED: Regression Rule Capture
diff --git a/src/features/swap/api/velora.ts b/src/features/swap/api/velora.ts
index 392e8b21..27f78c25 100644
--- a/src/features/swap/api/velora.ts
+++ b/src/features/swap/api/velora.ts
@@ -365,14 +365,11 @@ export const buildVeloraTransactionPayload = async ({
     });
   }
 
-  const quotedSourceAmount = parseVeloraBigIntField(priceRoute.srcAmount, 'priceRoute.srcAmount', priceRoute);
-  if (quotedSourceAmount !== srcAmount) {
-    throw new VeloraApiError('Velora route source amount does not match the requested transaction source amount', 400, {
-      requestedSourceAmount: srcAmount.toString(),
-      quotedSourceAmount: quotedSourceAmount.toString(),
-      priceRoute,
-    });
-  }
+  // The transaction request's `srcAmount` is the execution-authoritative sell amount.
+  // Some routes can echo non-authoritative source metadata while still producing calldata
+  // with the exact requested sell amount, so we validate the built payload downstream
+  // instead of rejecting here on route metadata alone.
+  parseVeloraBigIntField(priceRoute.srcAmount, 'priceRoute.srcAmount', priceRoute);
 
   const query = new URLSearchParams();
   if (ignoreChecks) {
diff --git a/src/hooks/deleverage/deleverageWithSwap.ts b/src/hooks/deleverage/deleverageWithSwap.ts
index 88612ca4..356011fc 100644
--- a/src/hooks/deleverage/deleverageWithSwap.ts
+++ b/src/hooks/deleverage/deleverageWithSwap.ts
@@ -110,15 +110,15 @@ export const deleverageWithSwap = async ({
   });
 
   const sellOffsets = getParaswapSellOffsets(swapTxPayload.data);
-  const quotedSellCollateralAmount = BigInt(swapSellPriceRoute.srcAmount);
   const quotedLoanAssetsOut = BigInt(swapSellPriceRoute.destAmount);
   const calldataSellCollateralAmount = readCalldataUint256(swapTxPayload.data, sellOffsets.exactAmount);
-  const calldataQuotedLoanAssetsOut = readCalldataUint256(swapTxPayload.data, sellOffsets.quotedAmount);
-  if (
-    quotedSellCollateralAmount !== withdrawCollateralAmount ||
-    calldataSellCollateralAmount !== withdrawCollateralAmount ||
-    calldataQuotedLoanAssetsOut !== quotedLoanAssetsOut
-  ) {
+  // Only validate execution-authoritative swap fields here:
+  // - exactAmount: the collateral amount the adapter will actually sell
+  // - limitAmount: the minimum loan assets the adapter must receive
+  //
+  // Paraswap's quotedAmount is informational route metadata, not the actual execution floor.
+  // Rejecting on that field creates false positives without improving flash-loan safety.
+  if (calldataSellCollateralAmount !== withdrawCollateralAmount) {
     throw new Error('Deleverage quote changed. Please review the updated preview and try again.');
   }
 
diff --git a/src/hooks/leverage/leverageWithSwap.ts b/src/hooks/leverage/leverageWithSwap.ts
index a8b8794a..c2a75425 100644
--- a/src/hooks/leverage/leverageWithSwap.ts
+++ b/src/hooks/leverage/leverageWithSwap.ts
@@ -185,14 +185,9 @@ export const leverageWithSwap = async ({
   }
 
   const sellOffsets = getParaswapSellOffsets(swapTxPayload.data);
-  const quotedSellAmount = BigInt(swapPriceRoute.srcAmount);
   const calldataSellAmount = readCalldataUint256(swapTxPayload.data, sellOffsets.exactAmount);
   const calldataMinCollateralOut = readCalldataUint256(swapTxPayload.data, sellOffsets.limitAmount);
-  if (
-    quotedSellAmount !== totalLoanSellAmount ||
-    calldataSellAmount !== totalLoanSellAmount ||
-    calldataMinCollateralOut !== collateralOutSlippageFloor
-  ) {
+  if (calldataSellAmount !== totalLoanSellAmount || calldataMinCollateralOut !== collateralOutSlippageFloor) {
     throw new Error('Leverage quote changed. Please review the updated preview and try again.');
   }
 
diff --git a/src/hooks/useDeleverageQuote.ts b/src/hooks/useDeleverageQuote.ts
index 2f18a0e7..323fbee6 100644
--- a/src/hooks/useDeleverageQuote.ts
+++ b/src/hooks/useDeleverageQuote.ts
@@ -118,12 +118,9 @@ export function useDeleverageQuote({
         side: 'SELL',
       });
 
-      const quotedSellCollateral = BigInt(sellRoute.srcAmount);
-      if (quotedSellCollateral !== withdrawCollateralAmount) {
-        throw new Error('Deleverage quote changed. Please review the updated preview and try again.');
-      }
-
       return {
+        // Preview uses the requested unwind amount as the authoritative sell size.
+        // The submit path still re-validates the executable calldata before sending.
         rawRouteRepayAmount: withSlippageFloor(BigInt(sellRoute.destAmount), slippageBps),
         priceRoute: sellRoute,
       };
diff --git a/src/hooks/useLeverageQuote.ts b/src/hooks/useLeverageQuote.ts
index 1d509dc7..58ecf223 100644
--- a/src/hooks/useLeverageQuote.ts
+++ b/src/hooks/useLeverageQuote.ts
@@ -167,12 +167,11 @@ export function useLeverageQuote({
         userAddress: swapExecutionAddress as `0x${string}`,
         side: 'SELL',
       });
-      if (BigInt(sellRoute.srcAmount) !== borrowAssets) {
-        throw new Error('Failed to quote stable Velora swap route for leverage.');
-      }
 
       return {
         flashLoanAssetAmount: borrowAssets,
+        // Quote preview uses the requested sell size as authoritative. The built calldata
+        // still has to prove that exact sell amount before leverage execution can proceed.
         flashLegCollateralTokenAmount: withSlippageFloor(BigInt(sellRoute.destAmount), slippageBps),
         priceRoute: sellRoute,
       };
@@ -218,9 +217,6 @@ export function useLeverageQuote({
         userAddress: swapExecutionAddress as `0x${string}`,
         side: 'SELL',
       });
-      if (BigInt(sellRoute.srcAmount) !== totalLoanSellAmount) {
-        throw new Error('Failed to quote stable Velora swap route for leverage.');
-      }
 
       const totalCollateralTokenAmountAdded = withSlippageFloor(BigInt(sellRoute.destAmount), slippageBps);
 
diff --git a/src/modals/leverage/components/add-collateral-and-leverage.tsx b/src/modals/leverage/components/add-collateral-and-leverage.tsx
index a3dfca08..b379cb20 100644
--- a/src/modals/leverage/components/add-collateral-and-leverage.tsx
+++ b/src/modals/leverage/components/add-collateral-and-leverage.tsx
@@ -637,11 +637,6 @@ export function AddCollateralAndLeverage({
                   </div>
                 )}
               </div>
-              <p className="mb-2 text-xs text-secondary">
-                {useLoanAssetInput
-                  ? `Enter the ${market.loanAsset.symbol} you want to start with. It will be converted into ${market.collateralAsset.symbol} during the leverage flow.`
-                  : `Enter the ${market.collateralAsset.symbol} you want to contribute before the flash leg.`}
-              </p>
               <Input
                 decimals={inputAssetDecimals}
                 max={inputAssetBalance}