@strkfarm/sdk 2.0.0-dev.28 → 2.0.0-dev.29

package/src/strategies/vesu-extended-strategy/services/extended-vesu-state-manager.ts

@@ -12,6 +12,8 @@ import {
   calculateExtendedLevergae,
   calculateVesuLeverage,
 } from "../utils/helper";
+import { VesuConfig } from "../utils/config.runtime";
+import { rebalance, type RebalanceDeltas } from "./ltv-imbalance-rebalance-math";
 
 // ─── State types ───────────────────────────────────────────────────────────────
 
@@ -58,6 +60,26 @@ export interface ExtendedBalanceState {
   pendingDeposit: Web3Number;
 }
 
+
+type Inputs = {
+  extAvlWithdraw: number;
+  extUpnl: number;
+  vaUsd: number;
+  walletUsd: number;
+  vesuBorrowCapacity: number;
+  vesuLeverage: number;
+  extendedLeverage: number;
+};
+
+type Deltas = {
+  dExtAvlWithdraw: number;
+  dExtUpnl: number;
+  dVaUsd: number;
+  dWalletUsd: number;
+  dVesuBorrowCapacity: number;
+  isExtendedToVesu: boolean;
+};
+
 /**
  * Generic token balance with USD valuation.
  */
@@ -99,9 +121,9 @@ export interface VesuPoolDelta {
  * Enumerates all possible fund-routing paths used during execution.
  */
 export enum RouteType {
-  /** P1: Deposit USDC.e from operator wallet directly to Extended exchange */
+  /** Deposit USDC from operator wallet directly to Extended exchange */
   WALLET_TO_EXTENDED = 'WALLET_TO_EXTENDED',
-  /** P2: USDC from vault allocator → swap to USDC.e → deposit to Extended */
+  /** USDC from vault allocator → deposit to Extended (via manager) */
   VA_TO_EXTENDED = 'VA_TO_EXTENDED',
   /** Withdraw from Extended exchange → operator wallet */
   EXTENDED_TO_WALLET = 'EXTENDED_TO_WALLET',
@@ -117,7 +139,7 @@ export enum RouteType {
   VESU_BORROW = 'VESU_BORROW',
   /** Repay USDC debt to Vesu (debtDelta < 0) */
   VESU_REPAY = 'VESU_REPAY',
-  /** Transfer USDC.e from operator wallet to vault allocator */
+  /** Transfer USDC from operator wallet to vault allocator */
   WALLET_TO_VA = 'WALLET_TO_VA',
   /** Realize PnL on Extended exchange */
   REALISE_PNL = 'REALISE_PNL',
@@ -284,11 +306,12 @@ export enum CaseCategory {
  */
 export enum CaseId {
   // LTV Rebalance
-  LTV_VESU_LOW_TO_EXTENDED = 'LTV_VESU_LOW_TO_EXTENDED',
-  LTV_EXTENDED_PROFITABLE_AVAILABLE = 'LTV_EXTENDED_PROFITABLE_AVAILABLE',
-  LTV_EXTENDED_PROFITABLE_REALIZE = 'LTV_EXTENDED_PROFITABLE_REALIZE',
-  LTV_VESU_HIGH_USE_VA_OR_WALLET = 'LTV_VESU_HIGH_USE_VA_OR_WALLET',
-  LTV_EXTENDED_HIGH_USE_VA_OR_WALLET = 'LTV_EXTENDED_HIGH_USE_VA_OR_WALLET',
+  MANAGE_LTV = 'MANAGE_LTV',
+  /** @deprecated use MANAGE_LTV */ LTV_VESU_LOW_TO_EXTENDED = 'LTV_VESU_LOW_TO_EXTENDED',
+  /** @deprecated use MANAGE_LTV */ LTV_EXTENDED_PROFITABLE_AVAILABLE = 'LTV_EXTENDED_PROFITABLE_AVAILABLE',
+  /** @deprecated use MANAGE_LTV */ LTV_EXTENDED_PROFITABLE_REALIZE = 'LTV_EXTENDED_PROFITABLE_REALIZE',
+  /** @deprecated use MANAGE_LTV */ LTV_VESU_HIGH_USE_VA_OR_WALLET = 'LTV_VESU_HIGH_USE_VA_OR_WALLET',
+  /** @deprecated use MANAGE_LTV */ LTV_EXTENDED_HIGH_USE_VA_OR_WALLET = 'LTV_EXTENDED_HIGH_USE_VA_OR_WALLET',
 
   // New Deposits / Excess Funds
   DEPOSIT_FRESH_VAULT = 'DEPOSIT_FRESH_VAULT',
@@ -324,7 +347,7 @@ export interface SolveCase {
 const CASE_THRESHOLD_USD = 5;
 const CASE_MIN_BRIDING_USD = 10;
 /** Decimal places for rounding collateral / exposure deltas in token terms (e.g. BTC) */
-const COLLATERAL_PRECISION = 4;
+export const COLLATERAL_PRECISION = 4;
 
 /** Safely create a Web3Number from a float, avoiding >15 significant digit errors */
 function safeUsdcWeb3Number(value: number): Web3Number {
@@ -346,19 +369,43 @@ export interface SolveCaseEntry {
  * Used to filter the global route list into per-case route subsets.
  */
 export const CASE_ROUTE_TYPES: Record<CaseId, RouteType[]> = {
-  // LTV Rebalance — Vesu side
-  [CaseId.LTV_VESU_HIGH_USE_VA_OR_WALLET]: [RouteType.WALLET_TO_VA, RouteType.VESU_REPAY], // use wallet to va if wallet has and va doesnt have enough
-  [CaseId.LTV_EXTENDED_PROFITABLE_AVAILABLE]: [RouteType.EXTENDED_TO_WALLET, RouteType.RETURN_TO_WAIT, RouteType.WALLET_TO_VA, RouteType.VESU_REPAY],
-  [CaseId.LTV_EXTENDED_PROFITABLE_REALIZE]: [RouteType.REALISE_PNL, RouteType.EXTENDED_TO_WALLET, RouteType.RETURN_TO_WAIT, RouteType.WALLET_TO_VA, RouteType.VESU_REPAY],
-  // LTV Rebalance — Extended side
-  [CaseId.LTV_EXTENDED_HIGH_USE_VA_OR_WALLET]: [RouteType.VA_TO_EXTENDED, RouteType.WALLET_TO_EXTENDED],
-  [CaseId.LTV_VESU_LOW_TO_EXTENDED]: [RouteType.VESU_BORROW, RouteType.VA_TO_EXTENDED],
+  // LTV Rebalance — unified
+  [CaseId.MANAGE_LTV]: [
+    RouteType.REALISE_PNL, RouteType.EXTENDED_TO_WALLET, RouteType.RETURN_TO_WAIT,
+    RouteType.WALLET_TO_VA, RouteType.VESU_BORROW, RouteType.VESU_REPAY, RouteType.VA_TO_EXTENDED,
+    RouteType.VESU_MULTIPLY_DECREASE_LEVER, RouteType.VESU_MULTIPLY_INCREASE_LEVER,
+    RouteType.AVNU_DEPOSIT_SWAP,
+    RouteType.EXTENDED_DECREASE_LEVER, RouteType.EXTENDED_INCREASE_LEVER,
+    // Second-phase VA / Extended funding after lever routes (same types may repeat).
+    RouteType.RETURN_TO_WAIT, RouteType.WALLET_TO_VA, RouteType.VA_TO_EXTENDED,
+  ],
+  /** @deprecated */ [CaseId.LTV_VESU_HIGH_USE_VA_OR_WALLET]: [RouteType.WALLET_TO_VA, RouteType.VESU_REPAY],
+  /** @deprecated */ [CaseId.LTV_EXTENDED_PROFITABLE_AVAILABLE]: [RouteType.EXTENDED_TO_WALLET, RouteType.RETURN_TO_WAIT, RouteType.WALLET_TO_VA, RouteType.VESU_REPAY],
+  /** @deprecated */ [CaseId.LTV_EXTENDED_PROFITABLE_REALIZE]: [RouteType.REALISE_PNL, RouteType.EXTENDED_TO_WALLET, RouteType.RETURN_TO_WAIT, RouteType.WALLET_TO_VA, RouteType.VESU_REPAY],
+  /** @deprecated */ [CaseId.LTV_EXTENDED_HIGH_USE_VA_OR_WALLET]: [RouteType.VA_TO_EXTENDED, RouteType.WALLET_TO_EXTENDED],
+  /** @deprecated */ [CaseId.LTV_VESU_LOW_TO_EXTENDED]: [RouteType.VESU_BORROW, RouteType.VA_TO_EXTENDED],
 
   // New Deposits
   // @dev, when handling routes, after VA_TO_EXTENDED and/or WALLET_TO_EXTENDED, return. bcz, funds take time to reach extended. Anyways, in next cycle, these funds will be computed to increase lever
   // Sequence: fund-movement transfers first (WALLET_TO_EXTENDED, VA_TO_EXTENDED, WALLET_TO_VA, EXTENDED_TO_WALLET),
   //           then RETURN_TO_WAIT, then optional second WALLET_TO_VA + RETURN_TO_WAIT, then lever routes.
-  [CaseId.DEPOSIT_FRESH_VAULT]: [RouteType.WALLET_TO_EXTENDED, RouteType.VA_TO_EXTENDED, RouteType.WALLET_TO_VA, RouteType.EXTENDED_TO_WALLET, RouteType.RETURN_TO_WAIT, RouteType.WALLET_TO_VA, RouteType.AVNU_DEPOSIT_SWAP, RouteType.VESU_MULTIPLY_INCREASE_LEVER, RouteType.EXTENDED_INCREASE_LEVER],
+  [CaseId.DEPOSIT_FRESH_VAULT]: [
+    // May repeat after MANAGE_LTV (VA top-up → Extended → wait → levers).
+    RouteType.WALLET_TO_VA,
+    RouteType.VA_TO_EXTENDED,
+    RouteType.RETURN_TO_WAIT,
+    RouteType.VA_TO_EXTENDED,
+    RouteType.VESU_BORROW,
+    RouteType.WALLET_TO_EXTENDED,
+    RouteType.VA_TO_EXTENDED,
+    RouteType.WALLET_TO_VA,
+    RouteType.EXTENDED_TO_WALLET,
+    RouteType.RETURN_TO_WAIT,
+    RouteType.WALLET_TO_VA,
+    RouteType.AVNU_DEPOSIT_SWAP,
+    RouteType.VESU_MULTIPLY_INCREASE_LEVER,
+    RouteType.EXTENDED_INCREASE_LEVER,
+  ],
   [CaseId.DEPOSIT_EXTENDED_AVAILABLE]: [RouteType.EXTENDED_TO_WALLET, RouteType.RETURN_TO_WAIT, RouteType.WALLET_TO_VA, RouteType.AVNU_DEPOSIT_SWAP, RouteType.VESU_MULTIPLY_INCREASE_LEVER, RouteType.EXTENDED_INCREASE_LEVER],
   [CaseId.DEPOSIT_VESU_BORROW_CAPACITY]: [RouteType.VESU_BORROW, RouteType.VA_TO_EXTENDED, RouteType.RETURN_TO_WAIT, RouteType.AVNU_DEPOSIT_SWAP, RouteType.VESU_MULTIPLY_INCREASE_LEVER, RouteType.EXTENDED_INCREASE_LEVER],
   [CaseId.DEPOSIT_COMBINATION]: [], // exroutes to be computed on the fly based on above sub routes and where deposit is available
@@ -393,6 +440,17 @@ const IMBALANCE_THRESHOLD_FRACTION = 0.0002; // 0.02%
  * Each entry maps a CaseId to its metadata and descriptive steps.
  */
 const CASE_DEFINITIONS: Record<CaseId, SolveCase> = {
+  [CaseId.MANAGE_LTV]: {
+    id: CaseId.MANAGE_LTV,
+    category: CaseCategory.LTV_REBALANCE,
+    title: 'LTV Rebalance: Unified Vesu repay + Extended margin management',
+    description: 'Manages both Vesu high-LTV repayment and Extended low-margin funding in a single pass.',
+    steps: [
+      'Compute vesu repay needed and extended margin needed',
+      'Allocate funds: VA > Wallet > ExtAvl > ExtUpnl for Vesu; Wallet > VA > Borrow for Extended',
+      'Build combined transfer and repay/margin routes',
+    ],
+  },
   [CaseId.LTV_VESU_LOW_TO_EXTENDED]: {
     id: CaseId.LTV_VESU_LOW_TO_EXTENDED,
     category: CaseCategory.LTV_REBALANCE,
@@ -619,9 +677,13 @@ export interface StateManagerConfig {
   extendedAdapter: ExtendedAdapter;
   vaultAllocator: ContractAddr;
   walletAddress: string;
+  /** Strategy / vault token — idle balance in the vault allocator is denominated in this asset */
   assetToken: TokenInfo;
-  /** USDC.e token for wallet balance checks during route computation */
-  usdceToken: TokenInfo;
+  /**
+   * Native USDC (Starknet) — operator wallet stablecoin balance is always read for this token,
+   * independent of {@link assetToken} (e.g. when the strategy vault uses another asset).
+   */
+  usdcToken: TokenInfo;
   /** Collateral token (e.g. WBTC) for wallet balance checks */
   collateralToken: TokenInfo;
   limitBalanceBufferFactor: number;
@@ -672,231 +734,734 @@ export function routeSummary(r: ExecutionRoute): string {
 /**
  * Single source of truth for all mutable state during a solve() call.
  *
- * Holds both the refreshed on-chain/off-chain state snapshots AND the
- * budget-tracking values consumed by sub-classifiers.  Spend methods
- * automatically keep `totalUnused` in sync.  State-mutation methods
- * (`applyVesuDelta`, `applyExtendedExposureDelta`, `applyExtendedBalanceChange`)
- * update the underlying snapshots so that downstream classifiers always
- * see the most up-to-date picture.
+ * Stores **raw** snapshots from refresh (no safety buffer applied in fields).
+ * Buffer {@link limitBalanceBufferFactor} is applied only in **getters** used
+ * during solve (caps, diagnostics). **Spend / add** methods mutate balances
+ * in **raw** USD only (no buffer on debits or credits).
+ *
+ * **Extended deposits** ({@link SolveBudget.addToExtAvailTrade}): while account equity is
+ * below required margin (Σ position value ÷ Extended leverage), incoming USDC is credited
+ * only to **balance** and **equity**. Only the excess is credited to **availableForWithdrawal**
+ * and **availableForTrade**, matching “margin first, then free collateral”.
  */
 export class SolveBudget {
-  // ── Refreshed state (mutable during solve) ──────────────────────────
-  unusedBalance: TokenBalance[];
-  walletBalance: TokenBalance | null;
-  vaultBalance: TokenBalance | null;
-  extendedPositions: ExtendedPositionState[];
-  extendedBalance: ExtendedBalanceState | null;
-  vesuPoolStates: VesuPoolState[];
-  vesuPerPoolDebtDeltasToBorrow: Web3Number[];
-  shouldVesuRebalance: boolean[]; // should be same length as vesuPerPoolDebtDeltasToBorrow
-
-  // ── Budget tracking (populated by initBudget) ──────────────────────
-  private _vaUsd: number = 0;
-  private _walletUsd: number = 0;
-  private _extAvailWithdraw: number = 0;
-  private _extAvailUpnl: number = 0;
-  private _extAvailTrade: number = 0;
-  private _extPendingDeposit: number = 0;
-  private _vesuBorrowCapacity: number = 0;
-  private _totalUnused: number = 0;
+  // ── Refreshed state (mutable during solve, raw on-chain / API values) ─
+  private unusedBalance: TokenBalance[];
+  private walletBalance: TokenBalance | null;
+  /** Idle {@link StateManagerConfig.assetToken} in the vault allocator */
+  private vaultAssetBalance: TokenBalance | null;
+  /**
+   * Idle {@link StateManagerConfig.usdcToken} in the vault allocator.
+   * When asset and USDC are the same token, this is null (all VA stablecoin is in {@link vaultAssetBalance} only).
+   */
+  private vaultUsdcBalance: TokenBalance | null;
+  private extendedPositions: ExtendedPositionState[];
+  private extendedBalance: ExtendedBalanceState | null;
+  private vesuPoolStates: VesuPoolState[];
+  private vesuPerPoolDebtDeltasToBorrow: Web3Number[];
+  private shouldVesuRebalance: boolean[]; // should be same length as vesuPerPoolDebtDeltasToBorrow
+
+  readonly assetToken: TokenInfo;
+  readonly usdcToken: TokenInfo;
 
   constructor(state: {
-    limitBalanceBufferFactor: number;
+    assetToken: TokenInfo;
+    usdcToken: TokenInfo;
     unusedBalance: TokenBalance[];
     walletBalance: TokenBalance | null;
-    vaultBalance: TokenBalance | null;
+    vaultAssetBalance: TokenBalance | null;
+    vaultUsdcBalance: TokenBalance | null;
     extendedPositions: ExtendedPositionState[];
     extendedBalance: ExtendedBalanceState | null;
     vesuPoolStates: VesuPoolState[];
   }) {
-    const buffer = state.limitBalanceBufferFactor;
-    this.unusedBalance = state.unusedBalance.map((item) => {
-      return {
-        ...item,
-        amount: item.amount.multipliedBy(1 - buffer),
-        usdValue: item.usdValue * (1 - buffer),
-      };
+    this.assetToken = state.assetToken;
+    this.usdcToken = state.usdcToken;
+
+    const cloneTb = (b: TokenBalance): TokenBalance => ({
+      token: b.token,
+      amount: new Web3Number(b.amount.toFixed(b.token.decimals), b.token.decimals),
+      usdValue: b.usdValue,
     });
-    this.walletBalance = state.walletBalance ? {
-      ...state.walletBalance,
-      amount: state.walletBalance.amount.multipliedBy(1 - buffer),
-      usdValue: state.walletBalance.usdValue * (1 - buffer),
-    } : null;
-    this.vaultBalance = state.vaultBalance ? {
-      ...state.vaultBalance,
-      amount: state.vaultBalance.amount.multipliedBy(1 - buffer),
-      usdValue: state.vaultBalance.usdValue * (1 - buffer),
-    } : null;
-    this.extendedPositions = state.extendedPositions;
-    this.extendedBalance = state.extendedBalance ? {
-      ...state.extendedBalance,
-      availableForTrade: state.extendedBalance.availableForTrade.multipliedBy(1 - buffer),
-      availableForWithdrawal: state.extendedBalance.availableForWithdrawal.multipliedBy(1 - buffer),
-      unrealisedPnl: state.extendedBalance.unrealisedPnl.multipliedBy(1 - buffer),
-      balance: state.extendedBalance.balance.multipliedBy(1 - buffer),
-    } : null;
-    this.vesuPoolStates = state.vesuPoolStates;
+
+    this.unusedBalance = state.unusedBalance.map((item) => cloneTb(item));
+    this.walletBalance = state.walletBalance ? cloneTb(state.walletBalance) : null;
+    this.vaultAssetBalance = state.vaultAssetBalance ? cloneTb(state.vaultAssetBalance) : null;
+    this.vaultUsdcBalance = state.vaultUsdcBalance ? cloneTb(state.vaultUsdcBalance) : null;
+
+    // Deep-clone mutable Extended / Vesu snapshots so route-building dry-runs (e.g. _classifyLTV)
+    // cannot mutate shared objects when callers reuse the same fixture for multiple budgets.
+    this.extendedPositions = state.extendedPositions.map((p) => ({
+      ...p,
+      size: new Web3Number(p.size.toFixed(8), 8),
+      valueUsd: new Web3Number(p.valueUsd.toFixed(USDC_TOKEN_DECIMALS), USDC_TOKEN_DECIMALS),
+    }));
+    this.extendedBalance = state.extendedBalance
+      ? {
+        equity: new Web3Number(
+          state.extendedBalance.equity.toFixed(USDC_TOKEN_DECIMALS),
+          USDC_TOKEN_DECIMALS,
+        ),
+        availableForTrade: new Web3Number(
+          state.extendedBalance.availableForTrade.toFixed(USDC_TOKEN_DECIMALS),
+          USDC_TOKEN_DECIMALS,
+        ),
+        availableForWithdrawal: new Web3Number(
+          state.extendedBalance.availableForWithdrawal.toFixed(USDC_TOKEN_DECIMALS),
+          USDC_TOKEN_DECIMALS,
+        ),
+        unrealisedPnl: new Web3Number(
+          state.extendedBalance.unrealisedPnl.toFixed(USDC_TOKEN_DECIMALS),
+          USDC_TOKEN_DECIMALS,
+        ),
+        balance: new Web3Number(
+          state.extendedBalance.balance.toFixed(USDC_TOKEN_DECIMALS),
+          USDC_TOKEN_DECIMALS,
+        ),
+        pendingDeposit: new Web3Number(
+          state.extendedBalance.pendingDeposit.toFixed(USDC_TOKEN_DECIMALS),
+          USDC_TOKEN_DECIMALS,
+        ),
+      }
+      : null;
+    this.vesuPoolStates = state.vesuPoolStates.map((p) => ({
+      ...p,
+      collateralAmount: new Web3Number(
+        p.collateralAmount.toFixed(p.collateralToken.decimals),
+        p.collateralToken.decimals,
+      ),
+      debtAmount: new Web3Number(
+        p.debtAmount.toFixed(p.debtToken.decimals),
+        p.debtToken.decimals,
+      ),
+    }));
     const vesuPerPoolDebtDeltasToBorrow = this._computeperPoolDebtDeltasToBorrow();
     assert(vesuPerPoolDebtDeltasToBorrow.length === this.vesuPoolStates.length, 'vesuPerPoolDebtDeltasToBorrow length must match vesuPoolStates length');
     this.vesuPerPoolDebtDeltasToBorrow = vesuPerPoolDebtDeltasToBorrow.map((item) => item.deltaDebt);
     this.shouldVesuRebalance = vesuPerPoolDebtDeltasToBorrow.map((item) => item.shouldRebalance);
   }
 
+  /** `1 - limitBalanceBufferFactor` — multiplier applied to raw notionals for “usable” USD. */
+  private _usableFraction(): number {
+    return 1;
+  }
+
   /**
-   * Initialise budget-tracking values from the current state snapshot.
-   * Must be called after state is populated and debt deltas are computed.
-   *
-   * Accounts for pendingDeposit:
-   * - pendingDeposit > 0: funds in transit TO Extended → increase effective Extended available-for-trade
-   * - pendingDeposit < 0: funds in transit FROM Extended → increase effective wallet balance
+   * Raw USD notional for a token row. USDC (and configured {@link usdcToken}) uses 1:1 from amount;
+   * non-stable assets (e.g. WBTC in VA) use {@link TokenBalance.usdValue} from the pricer at refresh.
+   */
+  private _rawTokenUsd(tb: TokenBalance | null | undefined): number {
+    if (!tb) return 0;
+    if (this.usdcToken.address.eq(tb.token.address)) {
+      return Number(tb.amount.toFixed(tb.token.decimals));
+    }
+    return tb.usdValue;
+  }
+
+  /** Apply safety buffer to a raw USD scalar. */
+  bufferedUsd(rawUsd: number): number {
+    return rawUsd * this._usableFraction();
+  }
+
+  /** Convert a buffered “usable” USD amount to raw nominal USD (inverse of {@link bufferedUsd}). */
+  rawUsdFromBuffered(bufferedUsd: number): number {
+    const bf = this._usableFraction();
+    assert(bf > 0, 'SolveBudget::rawUsdFromBuffered usable fraction must be positive');
+    return bufferedUsd / bf;
+  }
+
+  /** Buffered USD notional for one token balance row. */
+  bufferedTokenUsd(tb: TokenBalance | null | undefined): number {
+    return this.bufferedUsd(this._rawTokenUsd(tb));
+  }
+
+  logStateSummary() {
+    console.log("===== state summary =====");
+    const aggregatedData = {
+      unusedBalances: this.unusedBalance.map((b) => ({
+        token: b.token.symbol,
+        amount: b.amount.toNumber(),
+      })),
+      walletBalance: this.walletBalance
+        ? {
+          token: this.walletBalance.token.symbol,
+          amount: this.walletBalance.amount.toNumber(),
+        }
+        : undefined,
+      vaultAssetBalance: this.vaultAssetBalance
+        ? {
+          token: this.vaultAssetBalance.token.symbol,
+          amount: this.vaultAssetBalance.amount.toNumber(),
+        }
+        : undefined,
+      vaultUsdcBalance: this.vaultUsdcBalance
+        ? {
+          token: this.vaultUsdcBalance.token.symbol,
+          amount: this.vaultUsdcBalance.amount.toNumber(),
+        }
+        : undefined,
+      vesuPoolStates: this.vesuPoolStates.map((p) => ({
+        poolId: p.poolId,
+        collateralAmount: p.collateralAmount.toNumber(),
+        debtAmount: p.debtAmount.toNumber(),
+      })),
+      vesuBorrowCapacity: this.vesuBorrowCapacity,
+      vesuRebalance: this.shouldVesuRebalance,
+      vesuPerPoolDebtDeltasToBorrow: this.vesuPerPoolDebtDeltasToBorrow.map((d) => d.toNumber()),
+      extendedBalance: this.extendedBalance?.balance.toNumber(),
+      extendedEquity: this.extendedBalance?.equity.toNumber(),
+      extendedAvailableForTrade: this.extendedBalance?.availableForTrade.toNumber(),
+      extendedAvailableForWithdrawal: this.extendedBalance?.availableForWithdrawal.toNumber(),
+      extendedUnrealisedPnl: this.extendedBalance?.unrealisedPnl.toNumber(),
+      extendedPendingDeposit: this.extendedBalance?.pendingDeposit.toNumber(),
+      extendedPositions: this.extendedPositions.map((p) => ({
+        instrument: p.instrument,
+        size: p.size.toNumber(),
+        valueUsd: p.valueUsd.toNumber(),
+      })),
+    }
+    // unused balances
+    console.log(
+      "unused balances",
+      aggregatedData.unusedBalances
+        .map((b) => `${b.token}=${b.amount}`)
+        .join(", "),
+    );
+    console.log(
+      "wallet balance",
+      aggregatedData.walletBalance
+        ? `${aggregatedData.walletBalance.token}=${aggregatedData.walletBalance.amount}`
+        : undefined,
+    );
+    console.log(
+      "vault asset balance",
+      aggregatedData.vaultAssetBalance
+        ? `${aggregatedData.vaultAssetBalance.token}=${aggregatedData.vaultAssetBalance.amount}`
+        : undefined,
+    );
+    console.log(
+      "vault usdc balance",
+      aggregatedData.vaultUsdcBalance
+        ? `${aggregatedData.vaultUsdcBalance.token}=${aggregatedData.vaultUsdcBalance.amount}`
+        : undefined,
+    );
+
+    // vesu info
+    console.log(
+      "vesu pool states",
+      aggregatedData.vesuPoolStates
+        .map(
+          (p) =>
+            `${p.poolId.shortString()}=${p.collateralAmount} ${p.debtAmount}`,
+        )
+        .join(", "),
+    );
+    console.log("vesu borrow capacity", aggregatedData.vesuBorrowCapacity);
+    console.log(
+      "vesu rebalance",
+      aggregatedData.vesuRebalance.map(String).join(", "),
+    );
+    console.log("vesu per pool debt deltas to borrow", aggregatedData.vesuPerPoolDebtDeltasToBorrow.join(", "));
+    // extended info
+    console.log("extended balance", aggregatedData.extendedBalance);
+    console.log("extended equity", aggregatedData.extendedEquity);
+    console.log("extended available for trade", aggregatedData.extendedAvailableForTrade);
+    console.log("extended available for withdrawal", aggregatedData.extendedAvailableForWithdrawal);
+    console.log("extended unrealised pnl", aggregatedData.extendedUnrealisedPnl);
+    console.log("extended pending deposit", aggregatedData.extendedPendingDeposit);
+    console.log(
+      "extended positions",
+      aggregatedData.extendedPositions
+        .map(
+          (p) => `${p.instrument}=${p.size} ${p.valueUsd}`,
+        )
+        .join(", "),
+    );
+
+    return aggregatedData
+  }
+
+  /**
+   * Initialise derived views for a solve cycle. Mutates only when pending
+   * withdrawal from Extended is in transit (credits wallet raw balance).
    */
   initBudget(): void {
-    const debtDeltaNum = this.vesuPerPoolDebtDeltasToBorrow.reduce((a, b) => a + b.toNumber(), 0);
-    let totalUnusedUsd = this.unusedBalance.reduce((a, b) => a + b.usdValue, 0);
-    if (debtDeltaNum > 0) totalUnusedUsd += debtDeltaNum;
-    const extAvailTrade = this.extendedBalance?.availableForTrade?.toNumber() ?? 0;
-    if (extAvailTrade > 0) totalUnusedUsd += extAvailTrade;
-    if (debtDeltaNum > 0) totalUnusedUsd += debtDeltaNum;
-
-    this._vaUsd = this.vaultBalance?.usdValue ?? 0;
-    this._walletUsd = this.walletBalance?.usdValue ?? 0;
-    this._extAvailWithdraw = this.extendedBalance?.availableForWithdrawal?.toNumber() ?? 0;
-    this._extAvailUpnl = this.extendedBalance?.unrealisedPnl?.toNumber() ?? 0;
-    this._extAvailTrade = extAvailTrade;
-    this._extPendingDeposit = this.extendedBalance?.pendingDeposit?.toNumber() ?? 0;
-    this._vesuBorrowCapacity = debtDeltaNum;
-    this._totalUnused = totalUnusedUsd;
-
-    // ! cannot assume like this. the assumpotion, raher is opposite. also, be
     const pendingDeposit = this.extendedBalance?.pendingDeposit?.toNumber() ?? 0;
-    if (pendingDeposit > 0) {
-      this._extAvailTrade += pendingDeposit;
-      this._totalUnused += pendingDeposit;
-      logger.debug(`SolveBudget::initBudget pendingDeposit=${pendingDeposit} -> increased extAvailTrade`);
-    } else if (pendingDeposit < 0) {
+    if (pendingDeposit < 0) {
       const inTransit = Math.abs(pendingDeposit);
-      this._walletUsd += inTransit;
-      this._totalUnused += inTransit;
-      logger.debug(`SolveBudget::initBudget pendingDeposit=${pendingDeposit} -> increased walletUsd by ${inTransit}`);
+      if (this.walletBalance) {
+        this._addUsdToTokenBalance(this.walletBalance, inTransit);
+      }
+      logger.debug(`SolveBudget::initBudget pendingDeposit=${pendingDeposit} -> increased wallet raw USD by ${inTransit}`);
     }
+
+    this._recomputeUnusedBalance();
+  }
+
+  /**
+   * Apply a safety buffer to all liquid balances (VA, wallet, extended trade/withdraw/upnl,
+   * unused balances). Call after withdrawal classification but before LTV/deposit classifiers
+   * so that withdrawal uses full raw amounts while subsequent classifiers see buffered values.
+   */
+  applyBuffer(factor: number): void {
+    if (factor <= 0 || factor >= 1) return;
+    const mult = 1 - factor;
+
+    const scaleTokenBalance = (tb: TokenBalance | null) => {
+      if (!tb) return;
+      const newAmount = tb.amount.multipliedBy(mult);
+      tb.amount = new Web3Number(newAmount.toFixed(tb.token.decimals), tb.token.decimals);
+      tb.usdValue = tb.usdValue * mult;
+    };
+
+    scaleTokenBalance(this.vaultAssetBalance);
+    scaleTokenBalance(this.vaultUsdcBalance);
+    scaleTokenBalance(this.walletBalance);
+    for (const ub of this.unusedBalance) {
+      scaleTokenBalance(ub);
+    }
+
+    if (this.extendedBalance) {
+      this.extendedBalance.availableForTrade = this.extendedBalance.availableForTrade.multipliedBy(mult);
+      this.extendedBalance.availableForWithdrawal = this.extendedBalance.availableForWithdrawal.multipliedBy(mult);
+      this.extendedBalance.unrealisedPnl = this.extendedBalance.unrealisedPnl.multipliedBy(mult);
+    }
+
+    this._recomputeUnusedBalance();
+  }
+
+  get vesuPoolState(): VesuPoolState {
+    assert(this.vesuPoolStates.length === 1, 'SolveBudget::vesuPoolState: vesuPoolStates length must be 1');
+    return this.vesuPoolStates[0];
+  }
+
+  // ── Derived getters (buffered where applicable) ─────────────────────
+
+  /** Buffered VA USD: strategy-asset slot + optional USDC slot. */
+  get vaUsd(): number {
+    return this.bufferedTokenUsd(this.vaultAssetBalance) + this.bufferedTokenUsd(this.vaultUsdcBalance);
+  }
+
+  /** Buffered USD in VA strategy-asset bucket only. */
+  get vaAssetUsd(): number {
+    return this.bufferedTokenUsd(this.vaultAssetBalance);
+  }
+
+  /** Buffered USD in VA USDC bucket (0 when asset === USDC). */
+  get vaUsdcUsd(): number {
+    return this.bufferedTokenUsd(this.vaultUsdcBalance);
+  }
+
+  get walletUsd(): number {
+    return this.bufferedUsd(this._rawTokenUsd(this.walletBalance));
+  }
+
+  get vaWalletUsd(): number {
+    // va buffered + wallet raw
+    return this.vaUsd + this.walletUsd;
+  }
+
+  get extAvailWithdraw(): number {
+    const raw = this.extendedBalance?.availableForWithdrawal?.toNumber() ?? 0;
+    return this.bufferedUsd(raw);
+  }
+
+  get extAvailUpnl(): number {
+    const raw = this.extendedBalance?.unrealisedPnl?.toNumber() ?? 0;
+    return this.bufferedUsd(raw);
+  }
+
+  /**
+   * Buffered Extended available-for-trade plus positive {@link ExtendedBalanceState.pendingDeposit}
+   * (deposit in transit is usable the same way as the pre-buffer implementation).
+   */
+  get extAvailTrade(): number {
+    const raw = this.extendedBalance?.availableForTrade?.toNumber() ?? 0;
+    let v = this.bufferedUsd(raw);
+    const pd = this.extendedBalance?.pendingDeposit?.toNumber() ?? 0;
+    if (pd > 0) v += pd;
+    return v;
+  }
+
+  get extPendingDeposit(): number {
+    return this.extendedBalance?.pendingDeposit?.toNumber() ?? 0;
+  }
+
+  /**
+   * Aggregate positive per-pool borrow headroom (USD). Repay/borrow routes update
+   * {@link vesuPerPoolDebtDeltasToBorrow}; no separate counter.
+   */
+  get vesuBorrowCapacity(): number {
+    return this.vesuPerPoolDebtDeltasToBorrow.reduce(
+      (a, d) => a + Math.max(0, d.toNumber()),
+      0,
+    );
+  }
+
+  /** Diagnostic: buffered idle + positive debt delta + buffered Extended afT + in-flight deposit. */
+  get totalUnused(): number {
+    const debtSum = this.vesuPerPoolDebtDeltasToBorrow.reduce((a, b) => a + b.toNumber(), 0);
+    let u = this.unusedBalance.reduce((a, b) => a + this.bufferedTokenUsd(b), 0);
+    if (debtSum > 0) u += debtSum;
+    const rawAft = this.extendedBalance?.availableForTrade?.toNumber() ?? 0;
+    const aftBuf = this.bufferedUsd(rawAft);
+    if (aftBuf > 0) u += aftBuf;
+    const pd = this.extendedBalance?.pendingDeposit?.toNumber() ?? 0;
+    if (pd > 0) u += pd;
+    return u;
+  }
+
+  /** Sum of buffered USD across merged unused-balance rows (VA + wallet). */
+  get unusedBalancesBufferedUsdSum(): number {
+    return this.unusedBalance.reduce((a, b) => a + this.bufferedTokenUsd(b), 0);
+  }
+
+  /** Read-only snapshot view for validation / logging. */
+  get unusedBalanceRows(): readonly TokenBalance[] {
+    return this.unusedBalance;
+  }
+
+  /** Read-only Vesu pool view for solve computations. */
+  get vesuPools(): readonly VesuPoolState[] {
+    return this.vesuPoolStates;
+  }
+
+  /** Read-only Extended positions view for solve computations. */
+  get extendedPositionsView(): readonly ExtendedPositionState[] {
+    return this.extendedPositions;
+  }
+
+  /** Read-only Extended balance view for diagnostics / margin checks. */
+  get extendedBalanceView(): ExtendedBalanceState | null {
+    return this.extendedBalance;
+  }
+
+  /** Current debt deltas per pool (positive=borrow, negative=repay). */
+  get vesuDebtDeltas(): readonly Web3Number[] {
+    return this.vesuPerPoolDebtDeltasToBorrow;
+  }
+
+  /** Per-pool rebalance flags derived from target HF checks. */
+  get vesuRebalanceFlags(): readonly boolean[] {
+    return this.shouldVesuRebalance;
+  }
+
+  /** Raw USD in VA (USDC slot + asset slot); spend caps when executing transfers. */
+  private _vaRawUsd(): number {
+    return this._rawTokenUsd(this.vaultUsdcBalance) + this._rawTokenUsd(this.vaultAssetBalance);
+  }
+
+  private _walletRawUsd(): number {
+    return this._rawTokenUsd(this.walletBalance);
+  }
+
+  // ── Token snapshot helpers (keep vault / wallet / unusedBalance aligned) ─
+
+  /** Remove up to `usd` notional from a token balance, scaling token amount proportionally. */
+  private _deductUsdFromTokenBalance(tb: TokenBalance, usd: number): void {
+    if (usd <= 0) return;
+    const take = Math.min(usd, tb.usdValue);
+    if (take <= 0) return;
+    const oldUsd = tb.usdValue;
+    const newUsd = Math.max(0, oldUsd - take);
+    tb.usdValue = newUsd;
+    if (oldUsd <= 0) return;
+    const ratio = newUsd / oldUsd;
+    tb.amount = new Web3Number(
+      (tb.amount.toNumber() * ratio).toFixed(tb.token.decimals),
+      tb.token.decimals,
+    );
   }
 
-  // ── Read-only getters ────────────────────────────────────────────────
+  /** Add USD notional; infers price from current amount/usd when possible, else 1:1. */
+  private _addUsdToTokenBalance(tb: TokenBalance, usd: number): void {
+    if (usd <= 0) return;
+    const amtNum = tb.amount.toNumber();
+    const price =
+      amtNum > 0 && tb.usdValue > 0 ? tb.usdValue / amtNum : 1;
+    const deltaTok = usd / price;
+    tb.usdValue += usd;
+    tb.amount = tb.amount.plus(
+      new Web3Number(deltaTok.toFixed(tb.token.decimals), tb.token.decimals),
+    );
+  }
+
+  /**
+   * Rebuilds {@link unusedBalance} from vault + wallet snapshots (same merge as refresh).
+   */
+  private _recomputeUnusedBalance(): void {
+    const balanceMap = new Map<string, TokenBalance>();
+
+    const merge = (b: TokenBalance | null) => {
+      if (!b) return;
+      const key = b.token.address.toString();
+      const row: TokenBalance = {
+        token: b.token,
+        amount: new Web3Number(b.amount.toFixed(b.token.decimals), b.token.decimals),
+        usdValue: b.usdValue,
+      };
+      const existing = balanceMap.get(key);
+      if (existing) {
+        existing.amount = new Web3Number(
+          existing.amount.plus(row.amount).toFixed(existing.token.decimals),
+          existing.token.decimals,
+        );
+        existing.usdValue += row.usdValue;
+      } else {
+        balanceMap.set(key, row);
+      }
+    };
 
-  get vaUsd(): number { return this._vaUsd; }
-  get walletUsd(): number { return this._walletUsd; }
-  get vaWalletUsd(): number { return this._vaUsd + this._walletUsd; }
-  get extAvailWithdraw(): number { return this._extAvailWithdraw; }
-  get extAvailUpnl(): number { return this._extAvailUpnl; }
-  get extAvailTrade(): number { return this._extAvailTrade; }
-  get vesuBorrowCapacity(): number { return this._vesuBorrowCapacity; }
-  get totalUnused(): number { return this._totalUnused; }
-  get extPendingDeposit(): number { return this._extPendingDeposit; }
+    merge(this.vaultAssetBalance);
+    merge(this.vaultUsdcBalance);
+    merge(this.walletBalance);
+
+    this.unusedBalance = Array.from(balanceMap.values());
+  }
 
   // ── Spend methods (return amount consumed, auto-decrement totalUnused) ─
 
-  spendVA(desired: number): number {
-    const used = Math.min(this._vaUsd, Math.max(0, desired));
-    this._vaUsd -= used;
-    this._totalUnused -= used;
-    logger.debug(`SolveBudget::spendVA used=${used}, vaUsd=${this._vaUsd}, totalUnused=${this._totalUnused}`);
-    return used;
+  /**
+   * Spend VA **raw** USD (up to {@link vaRawUsd}). Prefer {@link vaultUsdcBalance} when present, then {@link vaultAssetBalance}.
+   */
+  spendVA(rawDesired: number): number {
+    const capRaw = this._vaRawUsd();
+    const usedRaw = Math.min(capRaw, Math.max(0, rawDesired));
+    if (usedRaw <= CASE_THRESHOLD_USD) return 0;
+    let rem = usedRaw;
+    if (rem > 0 && this.vaultUsdcBalance && this.vaultUsdcBalance.usdValue > 0) {
+      const fromUsdc = Math.min(rem, this.vaultUsdcBalance.usdValue);
+      this._deductUsdFromTokenBalance(this.vaultUsdcBalance, fromUsdc);
+      rem -= fromUsdc;
+    }
+    if (rem > 0 && this.vaultAssetBalance) {
+      this._deductUsdFromTokenBalance(this.vaultAssetBalance, rem);
+    }
+    this._recomputeUnusedBalance();
+    logger.debug(`SolveBudget::spendVA usedRaw=${usedRaw}, vaUsd=${this.vaUsd}, totalUnused=${this.totalUnused}`);
+    return usedRaw;
   }
 
-  addToVA(amount: number): void {
-    assert(amount >= 0, 'SolveBudget::addToVA amount must be positive');
-    this._vaUsd += amount;
-    this._totalUnused += amount;
-    logger.debug(`SolveBudget::addToVA amount=${amount}, vaUsd=${this._vaUsd}, totalUnused=${this._totalUnused}`);
+  /**
+   * Spend nominal/raw USD from VA (e.g. Vesu repay, on-chain USDC). Does not apply the safety buffer to the cap.
+   */
+  spendVaRawUsd(rawUsdDesired: number): number {
+    const capRaw =
+      this._rawTokenUsd(this.vaultUsdcBalance) + this._rawTokenUsd(this.vaultAssetBalance);
+    const usedRaw = Math.min(capRaw, Math.max(0, rawUsdDesired));
+    if (usedRaw <= CASE_THRESHOLD_USD) return 0;
+    let rem = usedRaw;
+    if (rem > 0 && this.vaultUsdcBalance && this.vaultUsdcBalance.usdValue > 0) {
+      const fromUsdc = Math.min(rem, this.vaultUsdcBalance.usdValue);
+      this._deductUsdFromTokenBalance(this.vaultUsdcBalance, fromUsdc);
+      rem -= fromUsdc;
+    }
+    if (rem > 0 && this.vaultAssetBalance) {
+      this._deductUsdFromTokenBalance(this.vaultAssetBalance, rem);
+    }
+    this._recomputeUnusedBalance();
+    logger.debug(`SolveBudget::spendVaRawUsd usedRaw=${usedRaw}, vaUsd=${this.vaUsd}, totalUnused=${this.totalUnused}`);
+    return usedRaw;
   }
 
-  spendWallet(desired: number): number {
-    const used = Math.min(this._walletUsd, Math.max(0, desired));
-    this._walletUsd -= used;
-    this._totalUnused -= used;
-    logger.debug(`SolveBudget::spendWallet used=${used}, walletUsd=${this._walletUsd}, totalUnused=${this._totalUnused}`);
-    return used;
+  /**
+   * Add **raw nominal USD** to VA (borrow proceeds, wallet→VA in raw USDC, etc.).
+   */
+  addToVA(rawUsd: number): void {
+    assert(rawUsd >= 0, 'SolveBudget::addToVA amount must be positive');
+    if (rawUsd === 0) return;
+    if (this.vaultUsdcBalance) {
+      this._addUsdToTokenBalance(this.vaultUsdcBalance, rawUsd);
+    } else if (this.vaultAssetBalance) {
+      this._addUsdToTokenBalance(this.vaultAssetBalance, rawUsd);
+    }
+    this._recomputeUnusedBalance();
+    logger.debug(`SolveBudget::addToVA rawUsd=${rawUsd}, vaUsd=${this.vaUsd}, totalUnused=${this.totalUnused}`);
   }
 
-  addToWallet(amount: number): void {
-    assert(amount >= 0, 'SolveBudget::addToWallet amount must be positive');
-    this._walletUsd += amount;
-    this._totalUnused += amount;
-    logger.debug(`SolveBudget::addToWallet amount=${amount}, walletUsd=${this._walletUsd}, totalUnused=${this._totalUnused}`);
+  spendWallet(rawDesired: number): number {
+    const capRaw = this._walletRawUsd();
+    const usedRaw = Math.min(capRaw, Math.max(0, rawDesired));
+    if (usedRaw <= CASE_THRESHOLD_USD) return 0;
+    if (this.walletBalance) {
+      this._deductUsdFromTokenBalance(this.walletBalance, usedRaw);
+    }
+    this._recomputeUnusedBalance();
+    logger.debug(`SolveBudget::spendWallet usedRaw=${usedRaw}, walletUsd=${this.walletUsd}, totalUnused=${this.totalUnused}`);
+    return usedRaw;
   }
 
-  spendVAWallet(desired: number): number {
-    let remaining = Math.max(0, desired);
+  /** Add **raw nominal USD** to the operator wallet balance (e.g. Extended→wallet withdrawal). */
+  addToWallet(rawUsd: number): void {
+    assert(rawUsd >= 0, 'SolveBudget::addToWallet amount must be positive');
+    if (rawUsd === 0) return;
+    if (this.walletBalance) {
+      this._addUsdToTokenBalance(this.walletBalance, rawUsd);
+    }
+    this._recomputeUnusedBalance();
+    logger.debug(`SolveBudget::addToWallet rawUsd=${rawUsd}, walletUsd=${this.walletUsd}, totalUnused=${this.totalUnused}`);
+  }
+
+  spendVAWallet(rawDesired: number): number {
+    let remaining = Math.max(0, rawDesired);
     const vaSpent = this.spendVA(remaining);
     remaining -= vaSpent;
     const walletSpent = this.spendWallet(remaining);
     return vaSpent + walletSpent;
   }
 
-  private _updateExtAvailWithdraw(desired: number, isSpend: boolean): number {
-    let amount = desired;
-    assert(amount > 0, 'SolveBudget::_updateExtAvailWithdraw amount must be positive');
+  private _updateExtAvailWithdraw(desiredRaw: number, isSpend: boolean): number {
+    assert(desiredRaw > 0, 'SolveBudget::_updateExtAvailWithdraw amount must be positive');
+    let rawDelta: number;
     if (isSpend) {
-      amount = Math.min(this._extAvailWithdraw, Math.max(0, desired));
-      amount = -amount; // invert sign
+      const capRaw = this.extendedBalance?.availableForWithdrawal?.toNumber() ?? 0;
+      const useRaw = Math.min(capRaw, desiredRaw);
+      if (useRaw <= CASE_THRESHOLD_USD) return 0;
+      rawDelta = -useRaw;
+    } else {
+      rawDelta = desiredRaw;
     }
-    this._extAvailWithdraw += amount;
-    this._totalUnused += amount;
-    this._extAvailTrade += amount;
 
-    // update extended balances
     if (this.extendedBalance) {
-      this.extendedBalance.availableForWithdrawal = safeUsdcWeb3Number(this.extendedBalance.availableForWithdrawal.toNumber() + amount);
-      this.extendedBalance.availableForTrade = safeUsdcWeb3Number(this.extendedBalance.availableForTrade.toNumber() + amount);
-      this.extendedBalance.balance = safeUsdcWeb3Number(this.extendedBalance.balance.toNumber() + amount);
-      this.extendedBalance.equity = safeUsdcWeb3Number(this.extendedBalance.equity.toNumber() + amount);
+      this.extendedBalance.availableForWithdrawal = safeUsdcWeb3Number(this.extendedBalance.availableForWithdrawal.toNumber() + rawDelta);
+      this.extendedBalance.availableForTrade = safeUsdcWeb3Number(this.extendedBalance.availableForTrade.toNumber() + rawDelta);
+      this.extendedBalance.balance = safeUsdcWeb3Number(this.extendedBalance.balance.toNumber() + rawDelta);
+      this.extendedBalance.equity = safeUsdcWeb3Number(this.extendedBalance.equity.toNumber() + rawDelta);
     }
-    logger.debug(`SolveBudget::updateExtAvailWithdraw amount=${amount}, extAvailWithdraw=${this._extAvailWithdraw}, totalUnused=${this._totalUnused}`);
-    return amount;
+    logger.debug(`SolveBudget::updateExtAvailWithdraw rawDelta=${rawDelta}, extAvailWithdraw=${this.extAvailWithdraw}, totalUnused=${this.totalUnused}`);
+    return rawDelta;
   }
 
-  private _updateExtAvailUpnl(desired: number, isSpend: boolean): number {
-    let amount = desired;
-    assert(amount > 0, 'SolveBudget::_updateExtAvailUpnl amount must be positive');
+  private _updateExtAvailUpnl(desiredRaw: number, isSpend: boolean): number {
+    assert(desiredRaw > 0, 'SolveBudget::_updateExtAvailUpnl amount must be positive');
+    let rawDelta: number;
     if (isSpend) {
-      amount = Math.min(this._extAvailUpnl, Math.max(0, desired));
-      amount = -amount; // invert sign
+      const capRaw = this.extendedBalance?.unrealisedPnl?.toNumber() ?? 0;
+      const useRaw = Math.min(capRaw, desiredRaw);
+      if (useRaw <= CASE_THRESHOLD_USD) return 0;
+      rawDelta = -useRaw;
+    } else {
+      rawDelta = desiredRaw;
     }
-    this._extAvailUpnl += amount;
-    this._totalUnused += amount;
 
-    // update extended balances
     if (this.extendedBalance) {
-      this.extendedBalance.unrealisedPnl = safeUsdcWeb3Number(this.extendedBalance.unrealisedPnl.toNumber() + amount);
-      this.extendedBalance.balance = safeUsdcWeb3Number(this.extendedBalance.balance.toNumber() + amount);
-      this.extendedBalance.equity = safeUsdcWeb3Number(this.extendedBalance.equity.toNumber() + amount);
-      this.extendedBalance.availableForTrade = safeUsdcWeb3Number(this.extendedBalance.availableForTrade.toNumber() + amount);
+      this.extendedBalance.unrealisedPnl = safeUsdcWeb3Number(this.extendedBalance.unrealisedPnl.toNumber() + rawDelta);
+      this.extendedBalance.balance = safeUsdcWeb3Number(this.extendedBalance.balance.toNumber() + rawDelta);
+      this.extendedBalance.equity = safeUsdcWeb3Number(this.extendedBalance.equity.toNumber() + rawDelta);
+      this.extendedBalance.availableForTrade = safeUsdcWeb3Number(this.extendedBalance.availableForTrade.toNumber() + rawDelta);
     }
-    logger.debug(`SolveBudget::updateExtAvailUpnl amount=${amount}, extAvailUpnl=${this._extAvailUpnl}, totalUnused=${this._totalUnused}`);
-    return amount;
+    logger.debug(`SolveBudget::updateExtAvailUpnl rawDelta=${rawDelta}, extAvailUpnl=${this.extAvailUpnl}, totalUnused=${this.totalUnused}`);
+    return rawDelta;
   }
 
-  spendExtAvailTrade(desired: number): number {
-    const used = this._updateExtAvailWithdraw(desired, true);
-    const usedUpnl = this._updateExtAvailUpnl(desired, true);
-    logger.debug(`SolveBudget::updateExtAvailTrade amount=${used + usedUpnl}, extAvailTrade=${this._extAvailTrade}, totalUnused=${this._totalUnused}`);
+  spendExtAvailTrade(rawDesired: number): number {
+    const used = this._updateExtAvailWithdraw(rawDesired, true);
+    const usedUpnl = this._updateExtAvailUpnl(rawDesired, true);
+    logger.debug(`SolveBudget::updateExtAvailTrade rawSum=${used + usedUpnl}, extAvailTrade=${this.extAvailTrade}, totalUnused=${this.totalUnused}`);
     return used + usedUpnl;
   }
 
-  spendExtAvailUpnl(desired: number): number {
-    return this._updateExtAvailUpnl(desired, true);
+  // simply reduces available amounts, but maintains equity and balance.
+  spendExtAvailTradeToEquityOnly(rawDesired: number): number {
+    const used = this._updateExtAvailWithdraw(rawDesired, true);
+    const remaining = rawDesired - Math.abs(used);
+    const usedUpnl = remaining > 0 ? this._updateExtAvailUpnl(remaining, true) : 0;
+    if (this.extendedBalance) {
+      // add whats subtracted earlier to equity
+      const net = Math.abs(used) + Math.abs(usedUpnl);
+      if (net.toFixed(0) != rawDesired.toFixed(0)) {
+        throw new Error(`SolveBudget::spendExtAvailTradeToEquityOnly net=${net} != rawDesired=${rawDesired}`);
+      }
+      this.extendedBalance.equity = safeUsdcWeb3Number(this.extendedBalance.equity.toNumber() + net);
+      this.extendedBalance.balance = safeUsdcWeb3Number(this.extendedBalance.balance.toNumber() + net);
+    }
+    logger.debug(`SolveBudget::updateExtAvailTrade rawSum=${used + usedUpnl}, extAvailTrade=${this.extAvailTrade}, totalUnused=${this.totalUnused}`);
+    return used + usedUpnl;
+  }
+
+  spendExtAvailWithdraw(rawDesired: number): number {
+    return this._updateExtAvailWithdraw(rawDesired, true);
+  }
+
+  spendExtAvailUpnl(rawDesired: number): number {
+    return this._updateExtAvailUpnl(rawDesired, true);
+  }
+
+  /**
+   * Withdraw from Extended **withdrawal bucket only** to operator wallet (planning).
+   * Used when VA must be funded from Extended and withdraw should be exhausted before unrealised PnL.
+   */
+  spendAvailWithdrawToWallet(rawDesired: number): number {
+    const want = Math.max(0, rawDesired);
+    if (want <= CASE_THRESHOLD_USD) return 0;
+    const rawDelta = this._updateExtAvailWithdraw(want, true);
+    if (rawDelta === 0) return 0;
+    const used = -rawDelta;
+    this.addToWallet(used);
+    return used;
+  }
+
+  /**
+   * Required Extended equity (USD) for current open positions: total notional ÷ strategy leverage.
+   * Same basis as {@link ExtendedSVKVesuStateManager._classifyLtvExtended} margin check.
+   */
+  private _extendedMarginRequirementUsd(): number {
+    const lev = calculateExtendedLevergae();
+    if (lev <= 0 || this.extendedPositions.length === 0) return 0;
+    const totalPosUsd = this.extendedPositions.reduce(
+      (s, p) => s + p.valueUsd.toNumber(),
+      0,
+    );
+    return totalPosUsd / lev;
   }
 
-  addToExtAvailTrade(amount: number): void {
-    this._updateExtAvailWithdraw(amount, false);
-    logger.debug(`SolveBudget::addToExtAvailTrade amount=${amount}, extAvailTrade=${this._extAvailTrade}, totalUnused=${this._totalUnused}`);
+  /** How much more equity is needed before deposits should increase withdraw / trade availability. */
+  private _extendedEquityShortfallUsd(): number {
+    if (!this.extendedBalance) return 0;
+    const req = this._extendedMarginRequirementUsd();
+    const eq = this.extendedBalance.equity.toNumber();
+    return Math.max(0, req - eq);
+  }
+
+  /**
+   * Credits a USDC inflow on Extended. Fills margin shortfall (balance+equity only) first;
+   * any remainder is credited across balance, equity, availableForWithdrawal, and availableForTrade.
+   */
+  addToExtAvailTrade(rawUsd: number): void {
+    assert(rawUsd >= 0, 'SolveBudget::addToExtAvailTrade amount must be non-negative');
+    if (rawUsd <= CASE_THRESHOLD_USD) return;
+    if (!this.extendedBalance) {
+      logger.warn('SolveBudget::addToExtAvailTrade skipped — no extendedBalance');
+      return;
+    }
+
+    const shortfall = this._extendedEquityShortfallUsd();
+    const toMargin = Math.min(rawUsd, shortfall);
+    const toLiquid = rawUsd - toMargin;
+
+    if (toMargin > CASE_THRESHOLD_USD) {
+      const b = this.extendedBalance.balance.toNumber();
+      const e = this.extendedBalance.equity.toNumber();
+      this.extendedBalance.balance = safeUsdcWeb3Number(b + toMargin);
+      this.extendedBalance.equity = safeUsdcWeb3Number(e + toMargin);
+      logger.debug(
+        `SolveBudget::addToExtAvailTrade margin-first rawUsd=${toMargin} ` +
+        `(shortfallBefore=${shortfall}, balance=${b + toMargin}, equity=${e + toMargin})`,
+      );
+    }
+
+    if (toLiquid > CASE_THRESHOLD_USD) {
+      this._updateExtAvailWithdraw(toLiquid, false);
+    }
+
+    logger.debug(
+      `SolveBudget::addToExtAvailTrade total rawUsd=${rawUsd} toLiquid=${toLiquid} ` +
+      `extAvailTrade=${this.extAvailTrade}, totalUnused=${this.totalUnused}`,
+    );
   }
 
   spendVesuBorrowCapacity(desired: number): { used: number, spendsByPool: Omit<VesuDebtRoute, 'priority' | 'type'>[] } {
-    const used = Math.min(this._vesuBorrowCapacity, Math.max(0, desired));
-    this._vesuBorrowCapacity -= used;
-    // todo check this function is used correctly
-    this._totalUnused -= used; // we assume only borrowed till ideal LTV
+    const used = Math.min(this.vesuBorrowCapacity, Math.max(0, desired));
 
     let spendsByPool: Omit<VesuDebtRoute, 'priority' | 'type'>[] = [];
     // reduce the debt delta for the pool
@@ -910,17 +1475,13 @@ export class SolveBudget {
       spendsByPool.push({ poolId: this.vesuPoolStates[index].poolId, amount: safeUsdcWeb3Number(borrowed), collateralToken: this.vesuPoolStates[index].collateralToken, debtToken: this.vesuPoolStates[index].debtToken });
     }
 
-    logger.debug(`SolveBudget::spendVesuBorrowCapacity used=${used}, vesuBorrowCapacity=${this._vesuBorrowCapacity}, totalUnused=${this._totalUnused}`);
+    logger.debug(`SolveBudget::spendVesuBorrowCapacity used=${used}, vesuBorrowCapacity=${this.vesuBorrowCapacity}, totalUnused=${this.totalUnused}`);
     return { used, spendsByPool };
   }
 
   repayVesuBorrowCapacity(desired: number): { used: number, spendsByPool: Omit<VesuDebtRoute, 'priority' | 'type'>[] } {
     assert(desired > 0, 'SolveBudget::repayVesuBorrowCapacity desired must be positive');
-    // const used = Math.min(this._vesuBorrowCapacity, Math.max(0, desired));
     const used = desired;
-    // todo check this function is used correctly
-    this._vesuBorrowCapacity += used;
-    // wont increase total unused because we are repaying debt
 
     const spendsByPool: Omit<VesuDebtRoute, 'priority' | 'type'>[] = [];
     for (let index = 0; index < this.vesuPerPoolDebtDeltasToBorrow.length; index++) {
@@ -932,7 +1493,7 @@ export class SolveBudget {
       spendsByPool.push({ poolId: this.vesuPoolStates[index].poolId, amount: safeUsdcWeb3Number(-repaid), collateralToken: this.vesuPoolStates[index].collateralToken, debtToken: this.vesuPoolStates[index].debtToken });
     }
 
-    logger.debug(`SolveBudget::repayVesuBorrowCapacity used=${used}, vesuBorrowCapacity=${this._vesuBorrowCapacity}, totalUnused=${this._totalUnused}`);
+    logger.debug(`SolveBudget::repayVesuBorrowCapacity used=${used}, vesuBorrowCapacity=${this.vesuBorrowCapacity}, totalUnused=${this.totalUnused}`);
     return { used, spendsByPool };
   }
 
@@ -958,14 +1519,28 @@ export class SolveBudget {
     // recompute per pool deltas here
     const vesuPerPoolDebtDeltasToBorrow = this._computeperPoolDebtDeltasToBorrow();
     this.vesuPerPoolDebtDeltasToBorrow = vesuPerPoolDebtDeltasToBorrow.map((item) => item.deltaDebt);
-    const sum = this.vesuPerPoolDebtDeltasToBorrow.reduce((a, b) => a.plus(b), new Web3Number(0, USDC_TOKEN_DECIMALS));
-    this._vesuBorrowCapacity = sum.toNumber();
     this.shouldVesuRebalance = vesuPerPoolDebtDeltasToBorrow.map((item) => item.shouldRebalance);
   }
 
-  /** Update an Extended position's size after a lever route. Creates the position if new. */
-  applyExtendedExposureDelta(instrument: string, sizeDelta: Web3Number): void {
-    const pos = this.extendedPositions.find((p) => p.instrument === instrument);
+  /**
+   * Update Extended position size after a lever route; sync {@link ExtendedPositionState.valueUsd}
+   * and margin buckets (released USD on decrease, locked USD on increase).
+   *
+   * @param collateralPriceUsd BTC collateral price for notional / margin math; if omitted, uses
+   *        existing valueUsd / |size| or the first Vesu pool collateral price.
+   */
+  applyExtendedExposureDelta(
+    instrument: string,
+    sizeDelta: Web3Number,
+    collateralPriceUsd?: number,
+  ): void {
+    const btcEps = 10 ** -COLLATERAL_PRECISION;
+    const lev = calculateExtendedLevergae();
+
+    let pos = this.extendedPositions.find((p) => p.instrument === instrument);
+    const oldAbs = pos ? Math.abs(pos.size.toNumber()) : 0;
+    const oldValUsd = pos ? pos.valueUsd.toNumber() : 0;
+
     if (pos) {
       pos.size = new Web3Number(pos.size.plus(sizeDelta).toFixed(8), 8);
     } else if (sizeDelta.toNumber() !== 0) {
@@ -976,6 +1551,62 @@ export class SolveBudget {
         valueUsd: new Web3Number(0, USDC_TOKEN_DECIMALS),
         leverage: '0',
       });
+      pos = this.extendedPositions[this.extendedPositions.length - 1];
+    } else {
+      return;
+    }
+
+    const newAbs = Math.abs(pos.size.toNumber());
+    let price = collateralPriceUsd;
+    if (price === undefined || price <= 0) {
+      price = oldAbs > btcEps ? oldValUsd / oldAbs : (this.vesuPoolStates[0]?.collateralPrice ?? 0);
+    }
+
+    if (price > 0) {
+      pos.valueUsd = new Web3Number(
+        (newAbs * price).toFixed(USDC_TOKEN_DECIMALS),
+        USDC_TOKEN_DECIMALS,
+      );
+    }
+
+    if (!this.extendedBalance || lev <= 0 || price <= 0) return;
+
+    const dAbs = newAbs - oldAbs;
+    if (dAbs < -btcEps) {
+      const releasedUsd = (-dAbs) * price / lev;
+      if (releasedUsd > CASE_THRESHOLD_USD) {
+        this.addToExtAvailTrade(releasedUsd);
+      }
+    } else if (dAbs > btcEps) {
+      const lockedUsd = dAbs * price / lev;
+      if (lockedUsd > CASE_THRESHOLD_USD) {
+        this._lockExtendedMarginUsd(lockedUsd);
+      }
+    }
+  }
+
+  /** Pull margin for larger Extended exposure from liquid buckets, then balance/equity. */
+  private _lockExtendedMarginUsd(lockedUsd: number): void {
+    if (lockedUsd <= CASE_THRESHOLD_USD || !this.extendedBalance) return;
+    let rem = lockedUsd;
+
+    const uw = Math.min(rem, Math.max(0, this.extendedBalance.availableForWithdrawal.toNumber()));
+    if (uw > 0) {
+      this._updateExtAvailWithdraw(uw, true);
+      rem -= uw;
+    }
+    if (rem > 0) {
+      const uu = Math.min(rem, Math.max(0, this.extendedBalance.unrealisedPnl.toNumber()));
+      if (uu > 0) {
+        this._updateExtAvailUpnl(uu, true);
+        rem -= uu;
+      }
+    }
+    if (rem > 0) {
+      const b = this.extendedBalance.balance.toNumber();
+      const e = this.extendedBalance.equity.toNumber();
+      this.extendedBalance.balance = safeUsdcWeb3Number(b - rem);
+      this.extendedBalance.equity = safeUsdcWeb3Number(e - rem);
     }
   }
 
@@ -1009,6 +1640,35 @@ export class SolveBudget {
   }
 }
 
+export function createSolveBudgetFromRawState(params: {
+  assetToken: TokenInfo;
+  usdcToken: TokenInfo;
+  unusedBalance: TokenBalance[];
+  walletBalance: TokenBalance | null;
+  vaultAssetBalance: TokenBalance | null;
+  vaultUsdcBalance: TokenBalance | null;
+  extendedPositions: ExtendedPositionState[];
+  extendedBalance: ExtendedBalanceState | null;
+  vesuPoolStates: VesuPoolState[];
+  limitBalanceBufferFactor?: number;
+}): SolveBudget {
+  const budget = new SolveBudget({
+    assetToken: params.assetToken,
+    usdcToken: params.usdcToken,
+    unusedBalance: params.unusedBalance,
+    walletBalance: params.walletBalance,
+    vaultAssetBalance: params.vaultAssetBalance,
+    vaultUsdcBalance: params.vaultUsdcBalance,
+    extendedPositions: params.extendedPositions,
+    extendedBalance: params.extendedBalance,
+    vesuPoolStates: params.vesuPoolStates,
+  });
+  if (params.limitBalanceBufferFactor && params.limitBalanceBufferFactor > 0) {
+    budget.applyBuffer(params.limitBalanceBufferFactor);
+  }
+  return budget;
+}
+
 // ─── State Manager ─────────────────────────────────────────────────────────────
 
 /**
@@ -1106,7 +1766,7 @@ export class ExtendedSVKVesuStateManager {
       vesuAllocationUsd: safeUsdcWeb3Number(0),
       extendedAllocationUsd: safeUsdcWeb3Number(0),
       bringLiquidityAmount: safeUsdcWeb3Number(0),
-      pendingDeposit: this._budget.extendedBalance?.pendingDeposit ?? new Web3Number(0, USDC_TOKEN_DECIMALS),
+      pendingDeposit: safeUsdcWeb3Number(0),
     };
 
     this._logSolveResult(result);
@@ -1125,32 +1785,58 @@ export class ExtendedSVKVesuStateManager {
     logger.info(`${this._tag}::_refresh starting`);
 
     const [
-      vaultAllocatorBalance,
+      vaultAssetBalance,
+      vaultUsdcBalance,
       walletBalance,
       vesuPoolStates,
       extendedBalance,
       extendedPositions,
     ] = await Promise.all([
-      this._fetchVaultAllocatorBalance(),
+      this._fetchVaultAllocatorAssetBalance(),
+      this._fetchVaultAllocatorUsdcBalanceIfDistinct(),
       this._fetchWalletBalances(),
       this._fetchAllVesuPoolStates(),
       this._fetchExtendedBalance(),
       this._fetchExtendedPositions(),
     ]);
 
-    logger.verbose(`_refresh vaultAllocatorBalance: ${vaultAllocatorBalance.usdValue}, walletBalance: ${walletBalance.usdValue}`);
+    logger.verbose(
+      `${this._tag}::_refresh VA asset ${vaultAssetBalance.token.symbol}=$${vaultAssetBalance.usdValue.toFixed(2)}` +
+      `${vaultUsdcBalance ? `, VA USDC=$${vaultUsdcBalance.usdValue.toFixed(2)}` : ""}` +
+      `, wallet=${walletBalance.usdValue}`,
+    );
     const unusedBalance = this._computeUnusedBalances(
-      vaultAllocatorBalance,
+      vaultAssetBalance,
+      vaultUsdcBalance,
       walletBalance,
     );
 
-    this._budget = new SolveBudget({
-      limitBalanceBufferFactor: this._config.limitBalanceBufferFactor,
+    this._budget = createSolveBudgetFromRawState({
+      assetToken: this._config.assetToken,
+      usdcToken: this._config.usdcToken,
       unusedBalance,
       walletBalance,
-      vaultBalance: vaultAllocatorBalance,
+      vaultAssetBalance,
+      vaultUsdcBalance,
       extendedPositions,
-      extendedBalance,
+      extendedBalance: {
+        availableForTrade:
+          extendedBalance?.availableForTrade ||
+          new Web3Number(0, USDC_TOKEN_DECIMALS),
+        availableForWithdrawal:
+          extendedBalance?.availableForWithdrawal ||
+          new Web3Number(0, USDC_TOKEN_DECIMALS),
+        unrealisedPnl:
+          extendedBalance?.unrealisedPnl ||
+          new Web3Number(0, USDC_TOKEN_DECIMALS),
+        balance:
+          extendedBalance?.balance || new Web3Number(0, USDC_TOKEN_DECIMALS),
+        equity:
+          extendedBalance?.equity || new Web3Number(0, USDC_TOKEN_DECIMALS),
+        pendingDeposit:
+          extendedBalance?.pendingDeposit ||
+          new Web3Number(0, USDC_TOKEN_DECIMALS),
+      },
       vesuPoolStates,
     });
 
@@ -1175,10 +1861,15 @@ export class ExtendedSVKVesuStateManager {
 
   // todo add communication check with python server of extended. if not working, throw error in solve function.
 
+  /** True when strategy asset and USDC share one token — VA USDC slot is unused (all in asset balance). */
+  private _vaultAssetAndUsdcAreSameToken(): boolean {
+    return this._config.assetToken.address.eq(this._config.usdcToken.address);
+  }
+
   /**
-   * Reads the asset-token balance sitting idle in the vault allocator contract.
+   * Reads the {@link StateManagerConfig.assetToken} balance idle in the vault allocator.
    */
-  private async _fetchVaultAllocatorBalance(): Promise<TokenBalance> {
+  private async _fetchVaultAllocatorAssetBalance(): Promise<TokenBalance> {
     const { assetToken, vaultAllocator, networkConfig, pricer } = this._config;
     const balance = await new ERC20(networkConfig).balanceOf(
       assetToken.address,
@@ -1193,25 +1884,48 @@ export class ExtendedSVKVesuStateManager {
   }
 
   /**
-   * Merges the vault-allocator balance and wallet balances into a
-   * deduplicated array of TokenBalance entries keyed by token address.
-   *
-   * e.g. VA has USDC, wallet has USDC + USDC.e → returns
-   *   [{ token: USDC, amount: VA+wallet, usdValue: … },
-   *    { token: USDC.e, amount: wallet, usdValue: … }]
+   * Reads {@link StateManagerConfig.usdcToken} in the vault allocator when it differs from
+   * {@link StateManagerConfig.assetToken}. Otherwise returns null (treat VA USDC as 0; stablecoin is only under asset).
+   */
+  private async _fetchVaultAllocatorUsdcBalanceIfDistinct(): Promise<TokenBalance | null> {
+    if (this._vaultAssetAndUsdcAreSameToken()) return null;
+
+    const { usdcToken, vaultAllocator, networkConfig, pricer } = this._config;
+    const balance = await new ERC20(networkConfig).balanceOf(
+      usdcToken.address,
+      vaultAllocator,
+      usdcToken.decimals,
+    );
+    const tokenPrice = await pricer.getPrice(
+      usdcToken.priceProxySymbol || usdcToken.symbol,
+    );
+    const usdValue =
+      Number(balance.toFixed(usdcToken.decimals)) * tokenPrice.price;
+
+    return { token: usdcToken, amount: balance, usdValue };
+  }
+
+  /**
+   * Merges vault-allocator asset, optional vault-allocator USDC, and operator wallet
+   * balances into entries keyed by token address.
    */
   private _computeUnusedBalances(
-    vaultAllocatorBalance: TokenBalance,
+    vaultAssetBalance: TokenBalance,
+    vaultUsdcBalance: TokenBalance | null,
     walletBalance: TokenBalance,
   ): TokenBalance[] {
     const balanceMap = new Map<string, TokenBalance>();
 
-    // Seed with vault-allocator balance
-    balanceMap.set(vaultAllocatorBalance.token.address.toString(), {
-      token: vaultAllocatorBalance.token,
-      amount: vaultAllocatorBalance.amount,
-      usdValue: vaultAllocatorBalance.usdValue,
-    });
+    const put = (tb: TokenBalance) => {
+      balanceMap.set(tb.token.address.toString(), {
+        token: tb.token,
+        amount: tb.amount,
+        usdValue: tb.usdValue,
+      });
+    };
+
+    put(vaultAssetBalance);
+    if (vaultUsdcBalance) put(vaultUsdcBalance);
 
     // Merge wallet balances by token address
     const key = walletBalance.token.address.toString();
@@ -1234,34 +1948,33 @@ export class ExtendedSVKVesuStateManager {
   }
 
   /**
-   * Reads the operator wallet's balances for the asset token (USDC.e) and
-   * USDC.e (needed for route computation — P1 vs P2 decision for Extended deposits).
+   * Reads the operator wallet balance for {@link StateManagerConfig.usdcToken} only
+   * (wallet stablecoin is always USDC, regardless of strategy {@link StateManagerConfig.assetToken}).
    */
   private async _fetchWalletBalances(): Promise<TokenBalance> {
     const {
       networkConfig,
       pricer,
       walletAddress,
-      assetToken,
-      usdceToken,
+      usdcToken,
     } = this._config;
     const erc20 = new ERC20(networkConfig);
 
-    const [usdceBalance, usdcePrice] =
+    const [balance, tokenPrice] =
       await Promise.all([
         erc20.balanceOf(
-          usdceToken.address,
+          usdcToken.address,
           walletAddress,
-          usdceToken.decimals,
+          usdcToken.decimals,
         ),
-        pricer.getPrice(usdceToken.priceProxySymbol || usdceToken.symbol),
+        pricer.getPrice(usdcToken.priceProxySymbol || usdcToken.symbol),
       ]);
 
     return {
-      token: usdceToken,
-      amount: usdceBalance,
+      token: usdcToken,
+      amount: balance,
       usdValue:
-        Number(usdceBalance.toFixed(usdceToken.decimals)) * usdcePrice.price,
+        Number(balance.toFixed(usdcToken.decimals)) * tokenPrice.price,
     };
   }
 
@@ -1390,12 +2103,12 @@ export class ExtendedSVKVesuStateManager {
    * finite, sensible values. Throws on invalid state.
    */
   private _validateRefreshedState(): void {
-    if (this._budget.unusedBalance.length === 0) {
+    if (this._budget.unusedBalanceRows.length === 0) {
       throw new Error(
         `${this._tag}: unusedBalance is empty after refresh`,
       );
     }
-    for (const balance of this._budget.unusedBalance) {
+    for (const balance of this._budget.unusedBalanceRows) {
       this._validateTokenBalanceOrThrow(
         balance,
         `unusedBalance[${balance.token.symbol}]`,
@@ -1420,7 +2133,7 @@ export class ExtendedSVKVesuStateManager {
   }
 
   private _validateVesuPoolPricesOrThrow(): void {
-    for (const pool of this._budget.vesuPoolStates) {
+    for (const pool of this._budget.vesuPools) {
       const poolLabel = pool.poolId.shortString();
       this._assertPositiveFinite(
         pool.collateralPrice,
@@ -1434,9 +2147,9 @@ export class ExtendedSVKVesuStateManager {
   }
 
   private _validateExtendedBalanceOrThrow(): void {
-    if (!this._budget.extendedBalance) return; // null is acceptable; treated as zero
+    if (!this._budget.extendedBalanceView) return; // null is acceptable; treated as zero
 
-    const { equity, availableForTrade } = this._budget.extendedBalance;
+    const { equity, availableForTrade } = this._budget.extendedBalanceView;
     if (
       !Number.isFinite(equity.toNumber()) ||
       !Number.isFinite(availableForTrade.toNumber())
@@ -1475,7 +2188,7 @@ export class ExtendedSVKVesuStateManager {
    * vault allocator to execute bringLiquidity.
    */
   private _computeDistributableAmount(
-    perPoolDebtDeltasToBorrow: Web3Number[],
+    perPoolDebtDeltasToBorrow: readonly Web3Number[],
     withdrawAmount: Web3Number,
   ): Web3Number {
     const totalInvestable = this._computeTotalInvestableAmount();
@@ -1490,27 +2203,34 @@ export class ExtendedSVKVesuStateManager {
   }
 
   /**
-   * Total investable = vault allocator balance + Extended available-for-trade,
-   * both reduced by the configured buffer percentage.
+   * Total investable = vault allocator balance + Extended available-for-trade +
+   * buffered unrealised PnL, matching `deposit_cases_extended_vesu.xlsx`:
+   * `(VA + wallet + EXT_WITH_AVL + EXT_UPNL) * (1 − buffer)`.
+   * Positive {@link ExtendedBalanceState.pendingDeposit} stays on the afT leg only (see {@link SolveBudget.extAvailTrade}).
    */
   private _computeTotalInvestableAmount(): Web3Number {
-    const totalUnusedUsd = this._budget.unusedBalance.reduce(
-      (acc, b) => acc + b.usdValue,
-      0,
-    );
+    const totalUnusedUsd = this._budget.unusedBalancesBufferedUsdSum;
     logger.debug(
       `${this._tag}::_computeTotalInvestableAmount unusedBalances=` +
-      `${JSON.stringify(this._budget.unusedBalance.map((b) => ({ token: b.token.symbol, amount: b.amount.toNumber(), usdValue: b.usdValue })))}`,
+      `${JSON.stringify(this._budget.unusedBalanceRows.map((b) => ({ token: b.token.symbol, amount: b.amount.toNumber(), usdValue: b.usdValue })))}`,
+    );
+    const extBal = this._budget.extendedBalanceView;
+    const rawAft = extBal?.availableForWithdrawal?.toNumber() ?? 0;
+    const rawUpnl = extBal?.unrealisedPnl?.toNumber() ?? 0;
+    let extBuffered =
+      this._budget.bufferedUsd(rawAft) + this._budget.bufferedUsd(rawUpnl);
+    const pd = extBal?.pendingDeposit?.toNumber() ?? 0;
+    if (pd > 0) extBuffered += pd;
+    const extendedAvailable = new Web3Number(
+      extBuffered.toFixed(USDC_TOKEN_DECIMALS),
+      USDC_TOKEN_DECIMALS,
     );
-    const extendedAvailable =
-      this._budget.extendedBalance?.availableForTrade ??
-      new Web3Number(0, USDC_TOKEN_DECIMALS);
     logger.verbose(`_computeTotalInvestableAmount totalUnusedUsd: ${totalUnusedUsd}, extendedAvailable: ${extendedAvailable.toNumber()}`);
     return new Web3Number(totalUnusedUsd.toFixed(USDC_TOKEN_DECIMALS), USDC_TOKEN_DECIMALS)
       .plus(extendedAvailable)
   }
 
-  private _sumDebtDeltas(deltas: Web3Number[]): Web3Number {
+  private _sumDebtDeltas(deltas: readonly Web3Number[]): Web3Number {
     return deltas.reduce(
       (sum, delta) => sum.plus(delta),
       new Web3Number(0, USDC_TOKEN_DECIMALS),
@@ -1548,7 +2268,7 @@ export class ExtendedSVKVesuStateManager {
     }
 
     // get long/short exposures on both sides
-    const collateralPrice = this._budget.vesuPoolStates[0]?.collateralPrice ?? 0;
+    const collateralPrice = this._budget.vesuPools[0]?.collateralPrice ?? 0;
     const totalVesuExposureUsd = this._totalVesuCollateralUsd().plus(new Web3Number((deltaVesuCollateral * collateralPrice).toFixed(6), USDC_TOKEN_DECIMALS));
     const totalExtendedExposureUsd = this._totalExtendedExposureUsd().plus(new Web3Number((deltaExtendedCollateral * collateralPrice).toFixed(6), USDC_TOKEN_DECIMALS));
 
@@ -1569,8 +2289,10 @@ export class ExtendedSVKVesuStateManager {
     );
 
     // add debt repayments to vesu allocation (-1 to convert to repay amount)
-    const perPoolDebtDeltasToBorrow = this._budget.vesuPerPoolDebtDeltasToBorrow;
-    vesuAllocationUsd = vesuAllocationUsd.plus(this._sumDebtDeltas(perPoolDebtDeltasToBorrow).multipliedBy(-1));
+    // const perPoolDebtDeltasToBorrow = this._budget.vesuDebtDeltas;
+    // const debtDeltasSum = this._sumDebtDeltas(perPoolDebtDeltasToBorrow);
+    // if (debtDeltasSum.toNumber() > 0) {
+    // vesuAllocationUsd = vesuAllocationUsd.plus(this._sumDebtDeltas(perPoolDebtDeltasToBorrow).multipliedBy(-1));
 
     let vesuPositionDelta = Number((new Web3Number((vesuAllocationUsd.toNumber() * (vesuLeverage) / collateralPrice).toFixed(6), 6)).toFixedRoundDown(COLLATERAL_PRECISION));
     let extendedPositionDelta = Number((new Web3Number((extendedAllocationUsd.toNumber() * (extendedLeverage) / collateralPrice).toFixed(6), 6)).toFixedRoundDown(COLLATERAL_PRECISION));
@@ -1599,19 +2321,23 @@ export class ExtendedSVKVesuStateManager {
    * token units.
    */
   private _computePerPoolCollateralDeltas(
-    vesuAllocationUsd: Web3Number, perPoolDebtDeltasToBorrow: Web3Number[]
+    vesuAllocationUsd: Web3Number
   ): VesuPoolDelta[] {
     const vesuLeverage = calculateVesuLeverage();
 
-    // remove any repayments from the vesu allocation
-    const availableVesuCollateralAllocationUsd = vesuAllocationUsd.plus(this._sumDebtDeltas(perPoolDebtDeltasToBorrow));
+    const availableVesuCollateralAllocationUsd = vesuAllocationUsd;
     const postLeverageAllocationUsd = availableVesuCollateralAllocationUsd.multipliedBy(vesuLeverage);
     const totalCollateralExisting = this._totalVesuCollateral();
 
-    return this._budget.vesuPoolStates.map((pool, index) => {
+    return this._budget.vesuPools.map((pool, index) => {
       const _postLeverageAllocation = postLeverageAllocationUsd.dividedBy(pool.collateralPrice);
 
-      const postLeverageAllocation = new Web3Number(((_postLeverageAllocation.plus(totalCollateralExisting)).toFixed(COLLATERAL_PRECISION)), pool.collateralToken.decimals).minus(totalCollateralExisting);
+      const postLeverageAllocation = new Web3Number((
+        (
+          _postLeverageAllocation.plus(totalCollateralExisting)
+        ).toFixedRoundDown(COLLATERAL_PRECISION)
+      ), pool.collateralToken.decimals
+      ).minus(totalCollateralExisting);
       const _poolCollateralDelta = this._computePoolCollateralShare(
         pool,
         totalCollateralExisting,
@@ -1623,12 +2349,12 @@ export class ExtendedSVKVesuStateManager {
       );
 
       // the excess collateral should come from debt.
-      const newDebt = postLeverageAllocationUsd.minus(availableVesuCollateralAllocationUsd).dividedBy(pool.debtPrice);
+      const newDebt = (postLeverageAllocation.multipliedBy(pool.collateralPrice)).minus(availableVesuCollateralAllocationUsd).dividedBy(pool.debtPrice);
       return {
         poolId: pool.poolId,
         collateralToken: pool.collateralToken,
         debtToken: pool.debtToken,
-        debtDelta: perPoolDebtDeltasToBorrow[index].plus(newDebt),
+        debtDelta: newDebt,
         collateralDelta: poolCollateralDelta,
         collateralPrice: pool.collateralPrice,
         debtPrice: pool.debtPrice,
@@ -1647,7 +2373,7 @@ export class ExtendedSVKVesuStateManager {
     totalVesuAllocation: Web3Number,
   ): Web3Number {
     const isSinglePoolOrZeroTotal =
-      this._budget.vesuPoolStates.length === 1 ||
+      this._budget.vesuPools.length === 1 ||
       totalCollateral.toNumber() === 0;
 
     if (isSinglePoolOrZeroTotal) return totalVesuAllocation;
@@ -1703,8 +2429,8 @@ export class ExtendedSVKVesuStateManager {
   ): Web3Number {
     let totalExposureCollateral = new Web3Number(0, USDC_TOKEN_DECIMALS); // just some decimals is ok
 
-    for (let i = 0; i < this._budget.vesuPoolStates.length; i++) {
-      const pool = this._budget.vesuPoolStates[i];
+    for (let i = 0; i < this._budget.vesuPools.length; i++) {
+      const pool = this._budget.vesuPools[i];
       const delta = vesuDeltas[i];
       logger.debug(
         `${this._tag}::_computeTargetExtendedExposure poolId=${pool.poolId.toString()}, collateralAmount=${pool.collateralAmount.toNumber()}, collateralDelta=${delta.collateralDelta.toNumber()}`,
@@ -1724,7 +2450,7 @@ export class ExtendedSVKVesuStateManager {
   }
 
   private _hasNoExtendedPositions(): boolean {
-    return this._budget.extendedPositions.length === 0;
+    return this._budget.extendedPositionsView.length === 0;
   }
 
   /**
@@ -1738,7 +2464,7 @@ export class ExtendedSVKVesuStateManager {
       {
         instrument: this._config.extendedAdapter.config.extendedMarketName,
         delta: new Web3Number(
-          delta.toFixed(COLLATERAL_PRECISION),
+          delta.toFixedRoundDown(COLLATERAL_PRECISION),
           USDC_TOKEN_DECIMALS,
         ),
       },
@@ -1754,7 +2480,7 @@ export class ExtendedSVKVesuStateManager {
   ): ExtendedPositionDelta[] {
     const totalExposure = this._totalExtendedExposure();
 
-    return this._budget.extendedPositions.map((position) => {
+    return this._budget.extendedPositionsView.map((position) => {
       const share = this._positionExposureShareFraction(
         position,
         totalExposure,
@@ -1762,7 +2488,7 @@ export class ExtendedSVKVesuStateManager {
       return {
         instrument: position.instrument,
         delta: new Web3Number(
-          totalDelta.multipliedBy(share).toFixed(COLLATERAL_PRECISION),
+          totalDelta.multipliedBy(share).toFixedRoundDown(COLLATERAL_PRECISION),
           USDC_TOKEN_DECIMALS,
         ),
       };
@@ -1780,7 +2506,7 @@ export class ExtendedSVKVesuStateManager {
   ): number {
     const isSingleOrZero =
       totalExposure.toNumber() === 0 ||
-      this._budget.extendedPositions.length === 1;
+      this._budget.extendedPositionsView.length === 1;
     if (isSingleOrZero) return 1;
     return position.valueUsd.dividedBy(totalExposure).toNumber();
   }
@@ -1796,9 +2522,10 @@ export class ExtendedSVKVesuStateManager {
   private _computeExtendedDepositDelta(
     extendedAllocationUsd: Web3Number,
   ): Web3Number {
-    const currentAvailableForTrade =
-      this._budget.extendedBalance?.availableForTrade ??
-      new Web3Number(0, USDC_TOKEN_DECIMALS);
+    const currentAvailableForTrade = new Web3Number(
+      this._budget.extAvailTrade.toFixed(USDC_TOKEN_DECIMALS),
+      USDC_TOKEN_DECIMALS,
+    );
 
     return new Web3Number(
       extendedAllocationUsd
@@ -1810,8 +2537,8 @@ export class ExtendedSVKVesuStateManager {
 
   private _computeVesuDepositAmount(vesuDeltas: VesuPoolDelta[]): Web3Number {
     let totalVesuCollateral = new Web3Number(0, USDC_TOKEN_DECIMALS); // just some decimals is ok
-    for (let i = 0; i < this._budget.vesuPoolStates.length; i++) {
-      const pool = this._budget.vesuPoolStates[i];
+    for (let i = 0; i < this._budget.vesuPools.length; i++) {
+      const pool = this._budget.vesuPools[i];
       const delta = vesuDeltas[i];
       totalVesuCollateral = totalVesuCollateral.plus(delta.collateralDelta.multipliedBy(pool.collateralPrice));
       totalVesuCollateral = totalVesuCollateral.minus(delta.debtDelta.multipliedBy(pool.debtPrice));
@@ -1868,15 +2595,23 @@ export class ExtendedSVKVesuStateManager {
       routes.push({ type: RouteType.VESU_REPAY as const, ...route, priority: routes.length });
     }
 
-    this._budget.spendVA(used);
+    this._budget.spendVaRawUsd(used);
   }
 
-  private _buildVesuBorrowRoutes(totalUsd: number, routes: ExecutionRoute[]): { routes: ExecutionRoute[], remaining: number } {
+  private _buildVesuBorrowRoutes(
+    totalUsd: number,
+    routes: ExecutionRoute[],
+    opts?: { maxBorrowUsd?: number },
+  ): { routes: ExecutionRoute[], remaining: number } {
     let borrowable = this._budget.vesuBorrowCapacity;
+    if (opts?.maxBorrowUsd !== undefined) {
+      borrowable = Math.min(borrowable, Math.max(0, opts.maxBorrowUsd));
+    }
     if (totalUsd <= CASE_THRESHOLD_USD) return { routes, remaining: totalUsd };
     if (borrowable <= CASE_THRESHOLD_USD) return { routes, remaining: totalUsd };
 
-    const { used, spendsByPool } = this._budget.spendVesuBorrowCapacity(totalUsd);
+    const borrowTarget = Math.min(totalUsd, borrowable);
+    const { used, spendsByPool } = this._budget.spendVesuBorrowCapacity(borrowTarget);
     for (const route of spendsByPool) {
       routes.push({ type: RouteType.VESU_BORROW as const, ...route, priority: routes.length });
     }
@@ -1937,9 +2672,9 @@ export class ExtendedSVKVesuStateManager {
   // }
 
   private _getWalletToVARoute(tryAmount: number, routes: ExecutionRoute[]): { routes: ExecutionRoute[], remaining: number } {
-    const usableAmount = Math.min(tryAmount, this._budget.walletUsd);
-    if (usableAmount > CASE_THRESHOLD_USD) {
-      const walletUsed = this._budget.spendWallet(usableAmount);
+    const usableRaw = Math.min(tryAmount, this._budget.walletUsd);
+    if (usableRaw > CASE_THRESHOLD_USD) {
+      const walletUsed = this._budget.spendWallet(usableRaw);
       this._budget.addToVA(walletUsed);
       const route: TransferRoute = { type: RouteType.WALLET_TO_VA, amount: safeUsdcWeb3Number(walletUsed), priority: routes.length };
       routes.push(route);
@@ -1949,9 +2684,9 @@ export class ExtendedSVKVesuStateManager {
   }
 
   private _getWalletToEXTENDEDRoute(tryAmount: number, routes: ExecutionRoute[], shouldAddWaitRoute = true): { routes: ExecutionRoute[], remaining: number } {
-    const usableAmount = Math.min(tryAmount, this._budget.walletUsd);
-    if (usableAmount > CASE_THRESHOLD_USD) {
-      const walletUsed = this._budget.spendWallet(usableAmount);
+    const usableRaw = Math.min(tryAmount, this._budget.walletUsd);
+    if (usableRaw > CASE_THRESHOLD_USD) {
+      const walletUsed = this._budget.spendWallet(usableRaw);
       this._budget.addToExtAvailTrade(walletUsed);
       routes.push({ type: RouteType.WALLET_TO_EXTENDED, amount: safeUsdcWeb3Number(walletUsed), priority: routes.length } as TransferRoute);
 
@@ -1964,9 +2699,9 @@ export class ExtendedSVKVesuStateManager {
   }
 
   private _getVAToEXTENDEDRoute(tryAmount: number, routes: ExecutionRoute[], shouldAddWaitRoute = true): { routes: ExecutionRoute[], remaining: number } {
-    const usableAmount = Math.min(tryAmount, this._budget.vaUsd);
-    if (usableAmount > CASE_THRESHOLD_USD) {
-      const vaUsed = this._budget.spendVA(usableAmount);
+    const usable = Math.min(tryAmount, this._budget.vaUsd);
+    if (usable > CASE_THRESHOLD_USD) {
+      const vaUsed = this._budget.spendVA(usable);
       this._budget.addToExtAvailTrade(vaUsed);
 
       // add extended deposit route
@@ -1984,24 +2719,25 @@ export class ExtendedSVKVesuStateManager {
 
   private _getExtendedToWalletRoute(tryAmount: number, routes: ExecutionRoute[], shouldAddWaitRoute = true): { routes: ExecutionRoute[], remaining: number } {
     if (tryAmount <= CASE_THRESHOLD_USD) return { routes, remaining: tryAmount };
-    assert(tryAmount <= this._budget.extAvailWithdraw, `tryAmount is greater than extAvailTrade, tryAmount: ${tryAmount}, extAvailWithdraw: ${this._budget.extAvailWithdraw}`);
-    const extWithdrawUsed = this._budget.spendExtAvailTrade(tryAmount);
-    this._budget.addToWallet(Math.abs(extWithdrawUsed));
-    const route: TransferRoute = { type: RouteType.EXTENDED_TO_WALLET, amount: safeUsdcWeb3Number(Math.abs(extWithdrawUsed)), priority: routes.length };
+    const rawCap = this._budget.extAvailWithdraw + this._budget.extAvailUpnl;
+    const rawSpend = Math.min(tryAmount, rawCap);
+    if (rawSpend <= CASE_THRESHOLD_USD) return { routes, remaining: tryAmount };
+    const rawOut = this._budget.spendExtAvailTrade(rawSpend);
+    this._budget.addToWallet(Math.abs(rawOut));
+    const route: TransferRoute = { type: RouteType.EXTENDED_TO_WALLET, amount: safeUsdcWeb3Number(rawSpend), priority: routes.length };
     routes.push(route);
 
     if (shouldAddWaitRoute) {
       routes.push({ type: RouteType.RETURN_TO_WAIT, priority: routes.length });
     }
-    return { routes, remaining: tryAmount - Math.abs(extWithdrawUsed) };
+    return { routes, remaining: tryAmount - rawSpend };
   }
 
   private _getWALLETToVARoute(tryAmount: number, routes: ExecutionRoute[]): { routes: ExecutionRoute[], remaining: number } {
     if (tryAmount <= CASE_THRESHOLD_USD) return { routes, remaining: tryAmount };
-    const usableAmount = Math.min(tryAmount, this._budget.walletUsd);
-    if (usableAmount <= CASE_THRESHOLD_USD) return { routes, remaining: tryAmount };
-    // assert(tryAmount <= this._budget.walletUsd, `tryAmount is greater than walletUsd, tryAmount: ${tryAmount}, walletUsd: ${this._budget.walletUsd}`);
-    const walletUsed = this._budget.spendWallet(tryAmount);
+    const usableRaw = Math.min(tryAmount, this._budget.walletUsd);
+    if (usableRaw <= CASE_THRESHOLD_USD) return { routes, remaining: tryAmount };
+    const walletUsed = this._budget.spendWallet(usableRaw);
     this._budget.addToVA(walletUsed);
     const route: TransferRoute = { type: RouteType.WALLET_TO_VA, amount: safeUsdcWeb3Number(walletUsed), priority: routes.length };
     routes.push(route);
@@ -2009,22 +2745,22 @@ export class ExtendedSVKVesuStateManager {
   }
 
   private _getUpnlRoute(tryAmount: number, routes: ExecutionRoute[]): { routes: ExecutionRoute[], remaining: number } {
-    const upnl = this._budget.extendedBalance?.unrealisedPnl?.toNumber() ?? 0;
-    const usableAmount = Math.min(tryAmount, upnl);
-    if (usableAmount <= CASE_THRESHOLD_USD) return { routes, remaining: tryAmount };
+    const rawUpnl = this._budget.extAvailUpnl;
+    const usableRaw = Math.min(tryAmount, rawUpnl);
+    if (usableRaw <= 0) return { routes, remaining: tryAmount };
 
     // if fails, ensure there is a way to choose the positio to use to create realised pnl
     // until then, only 1 position is supported
-    const upnlUsed = this._budget.spendExtAvailUpnl(usableAmount); // removes from upnl
-    this._budget.addToExtAvailTrade(upnlUsed); // adds to available-for-withdrawal
-    assert(this._budget.extendedPositions.length == 1, 'SolveBudget::_getUpnlRoute: extendedPositions length must be 1');
+    this._budget.spendExtAvailUpnl(usableRaw);
+    this._budget.addToExtAvailTrade(usableRaw);
+    assert(this._budget.extendedPositionsView.length == 1, 'SolveBudget::_getUpnlRoute: extendedPositions length must be 1');
     routes.push({
       type: RouteType.REALISE_PNL,
-      amount: safeUsdcWeb3Number(upnlUsed),
-      instrument: this._budget.extendedPositions[0].instrument,
+      amount: safeUsdcWeb3Number(usableRaw),
+      instrument: this._budget.extendedPositionsView[0].instrument,
       priority: routes.length,
     } as RealisePnlRoute);
-    return { routes, remaining: tryAmount - upnlUsed };
+    return { routes, remaining: tryAmount - usableRaw };
   }
 
   // ── Sub-classifiers ────────────────────────────────────────────────────
@@ -2047,7 +2783,7 @@ export class ExtendedSVKVesuStateManager {
 
     // ── Step 1: VA balance ────────────────────────────────────────────────
     // VA funds are already in the vault allocator — no transfer route needed.
-    const vaUsed = this._budget.spendVA(Math.min(this._budget.vaUsd, remaining));
+    const vaUsed = this._budget.spendVA(remaining);
     remaining -= vaUsed;
 
     let totalExtUsed = 0;
@@ -2080,62 +2816,110 @@ export class ExtendedSVKVesuStateManager {
       totalExtUsed = usableWithrawAmount + upnlUsed;
     }
 
-    // ── Step 5: Unwind positions on both sides ───────────────────────────
-    // Decrease Vesu lever + Extended exposure by equal BTC amounts to
-    // maintain delta neutrality. Freed funds are picked up next cycle.
+    // ── Step 5: Unwind positions ────────────────────────────────────────
+    // Handle imbalance first (unwind from larger side), then equal unwind.
+    // VESU_MULTIPLY_DECREASE_LEVER handles the BTC→USDC swap internally.
     if (remaining > CASE_THRESHOLD_USD) {
-      const avgCollPrice = this._budget.vesuPoolStates[0]?.collateralPrice ?? 1;
-      assert(this._budget.vesuPoolStates.length == 1, 'SolveBudget::_classifyWithdrawal: vesuPoolStates length must be 1');
-      // below function doesnt handle multiple pools yet
-      const { vesuPositionDelta, extendedPositionDelta, vesuAllocationUsd, extendedAllocationUsd } = this._computeAllocationSplit(new Web3Number((-remaining).toFixed(6), USDC_TOKEN_DECIMALS));
-
-      if (vesuPositionDelta < 0) {
-        const vesuAdapter = this._config.vesuAdapters[0];
-        const debtDelta = Math.min(0, vesuPositionDelta * avgCollPrice - vesuAllocationUsd.toNumber());
-        const withdrawAmount = vesuAllocationUsd.dividedBy(avgCollPrice);
-        withdrawAmount.decimals = vesuAdapter.config.collateral.decimals;
+      assert(this._budget.vesuPools.length == 1, 'SolveBudget::_classifyWithdrawal: vesuPoolStates length must be 1');
+      const vesuAdapter = this._config.vesuAdapters[0];
+      const avgCollPrice = this._budget.vesuPools[0]?.collateralPrice ?? 1;
+      const vesuLeverage = calculateVesuLeverage();
+      const extLeverage = calculateExtendedLevergae();
+      const freedPerBtcVesu = avgCollPrice / vesuLeverage;
+      const freedPerBtcExt = avgCollPrice / extLeverage;
+
+      const vesuColBtc = this._budget.vesuPools[0].collateralAmount.toNumber();
+      const extPosBtc = this._totalExtendedExposure().toNumber();
+      let stillNeeded = remaining;
+      let vesuBtcDelta = 0;
+      let extBtcDelta = 0;
+      let extFreed = 0;
+
+      const roundUpBtc = (x: number): number => {
+        const factor = 10 ** COLLATERAL_PRECISION;
+        return Math.ceil(x * factor) / factor;
+      };
+
+      // Step 5a: Handle imbalance
+      const diff = vesuColBtc - extPosBtc;
+      let currentVesuBtc = vesuColBtc;
+      let currentExtBtc = extPosBtc;
+
+      if (Math.abs(diff) > 1e-8) {
+        if (diff > 0) {
+          const btcRaw = stillNeeded / freedPerBtcVesu;
+          const btc = Math.min(roundUpBtc(Math.min(Math.abs(diff), btcRaw, currentVesuBtc)), currentVesuBtc);
+          vesuBtcDelta += btc;
+          stillNeeded -= btc * freedPerBtcVesu;
+          currentVesuBtc -= btc;
+        } else {
+          const btcRaw = stillNeeded / freedPerBtcExt;
+          const btc = Math.min(roundUpBtc(Math.min(Math.abs(diff), btcRaw, currentExtBtc)), currentExtBtc);
+          extBtcDelta += btc;
+          extFreed += btc * freedPerBtcExt;
+          stillNeeded -= btc * freedPerBtcExt;
+          currentExtBtc -= btc;
+        }
+      }
+
+      // Step 5b: Equal unwind from both sides
+      if (stillNeeded > CASE_THRESHOLD_USD) {
+        const combinedFreed = freedPerBtcVesu + freedPerBtcExt;
+        const maxBtc = Math.min(currentVesuBtc, currentExtBtc);
+        const btcRaw = stillNeeded / combinedFreed;
+        const btc = Math.min(roundUpBtc(Math.min(btcRaw, maxBtc)), maxBtc);
+        vesuBtcDelta += btc;
+        extBtcDelta += btc;
+        extFreed += btc * freedPerBtcExt;
+      }
+
+      const r6 = (n: number) => Number(n.toFixed(6));
+
+      // Emit VESU_MULTIPLY_DECREASE_LEVER (handles swap internally, freed funds go to VA)
+      if (vesuBtcDelta > 0) {
+        const totalVesuBtcSigned = -vesuBtcDelta;
+        const targetLtv = 1 - 1 / vesuLeverage; // vesuLeverage = 1/(1-ltv), so ltv = 1-1/lev
+        const debtDelta = r6(totalVesuBtcSigned * avgCollPrice * targetLtv);
+        // Same convention as LTV rebalance: no separate margin BTC; full Vesu reduction is the swap leg.
+        const marginBtc = 0;
+        const swappedBtc = Number(vesuBtcDelta.toFixed(COLLATERAL_PRECISION));
+
         routes.push({
           type: RouteType.VESU_MULTIPLY_DECREASE_LEVER,
           poolId: vesuAdapter.config.poolId,
           collateralToken: vesuAdapter.config.collateral,
-          marginAmount: withdrawAmount,
-          swappedCollateralAmount: (new Web3Number(vesuPositionDelta, vesuAdapter.config.collateral.decimals)).minus(withdrawAmount),
+          marginAmount: new Web3Number(marginBtc.toFixed(COLLATERAL_PRECISION), vesuAdapter.config.collateral.decimals),
+          swappedCollateralAmount: new Web3Number(swappedBtc.toFixed(COLLATERAL_PRECISION), vesuAdapter.config.collateral.decimals),
           debtToken: vesuAdapter.config.debt,
           debtAmount: new Web3Number(debtDelta, USDC_TOKEN_DECIMALS),
           priority: routes.length,
         } as VesuMultiplyRoute);
-        this._budget.applyVesuDelta(vesuAdapter.config.poolId, vesuAdapter.config.collateral, vesuAdapter.config.debt, new Web3Number(vesuPositionDelta, USDC_TOKEN_DECIMALS), new Web3Number(debtDelta, USDC_TOKEN_DECIMALS));
-
-        // Swap freed BTC → USDC (exact amount determined at runtime)
-        if (vesuAllocationUsd.toNumber() < -CASE_THRESHOLD_USD) {
-          const swapAmount = new Web3Number(((vesuAllocationUsd.toNumber() / avgCollPrice) * 0.998).toFixed(6), USDC_TOKEN_DECIMALS);
-          routes.push({
-            type: RouteType.AVNU_WITHDRAW_SWAP,
-            fromToken: vesuAdapter.config.collateral.symbol,
-            // add buffer to avoid rounding errors
-            fromAmount: swapAmount,
-            toToken: vesuAdapter.config.debt.symbol,
-            priority: routes.length,
-          } as SwapRoute);
-          this._budget.addToVA(vesuAllocationUsd.abs().toNumber());
-        }
+        this._budget.applyVesuDelta(
+          vesuAdapter.config.poolId, vesuAdapter.config.collateral, vesuAdapter.config.debt,
+          new Web3Number(r6(totalVesuBtcSigned), USDC_TOKEN_DECIMALS),
+          new Web3Number(debtDelta, USDC_TOKEN_DECIMALS),
+        );
+        this._budget.addToVA(vesuBtcDelta * freedPerBtcVesu);
       }
 
-
-      if (extendedPositionDelta < 0) {
-        // Decrease Extended exposure by the same BTC amount
+      // Emit EXTENDED_DECREASE_LEVER
+      if (extBtcDelta > 0) {
         routes.push({
           type: RouteType.EXTENDED_DECREASE_LEVER,
-          amount: safeUsdcWeb3Number(extendedPositionDelta),
+          amount: safeUsdcWeb3Number(-r6(extBtcDelta)),
           instrument,
           priority: routes.length,
         });
-        this._budget.applyExtendedExposureDelta(instrument, safeUsdcWeb3Number(extendedPositionDelta));
-        this._budget.addToExtAvailTrade(extendedAllocationUsd.abs().toNumber());
-        totalExtUsed += extendedAllocationUsd.abs().toNumber();
+        this._budget.applyExtendedExposureDelta(
+          instrument,
+          safeUsdcWeb3Number(-r6(extBtcDelta)),
+          avgCollPrice,
+        );
+        totalExtUsed += extFreed;
       }
     }
 
+    // Bridge extended funds to VA (availableForTrade → wallet → VA)
     if (totalExtUsed > CASE_THRESHOLD_USD) {
       this._getExtendedToWalletRoute(totalExtUsed, routes);
       this._getWALLETToVARoute(totalExtUsed, routes);
@@ -2169,72 +2953,275 @@ export class ExtendedSVKVesuStateManager {
    *
    * Design: accumulate all ext-to-wallet moves, add transfer routes at the end (principle #3).
    */
-  private _classifyLtvVesu(): SolveCaseEntry[] {
-    const debtDeltaSum = this._budget.vesuPerPoolDebtDeltasToBorrow.reduce(
-      (a, b) => a + b.toNumber(), 0,
+  /**
+   * Unified LTV classifier. Computes both Vesu repay and Extended margin needs,
+   * then builds all routes in a single pass with no duplicate transfers.
+   *
+   * Vesu repay priority: VA > Wallet > ExtAvl > ExtUpnl
+   * Extended margin priority: Wallet > VA > VesuBorrow
+   * Shared sources consumed by Vesu first (higher priority).
+   */
+  private _classifyLTV(): SolveCaseEntry[] {
+    assert(this._budget.vesuPools.length === 1, `${this._tag}::_classifyLTV expects exactly one Vesu pool`);
+    const d = rebalance(this._ltvRebalanceInputsFromBudget());
+    if (this._isLtvRebalanceNoop(d)) return [];
+
+    logger.info(
+      `${this._tag}::_classifyLTV deltas extPos=${d.dExtPosition} vesuPos=${d.dVesuPosition} `
+      + `vesuDebt=${d.dVesuDebt} va=${d.dVaUsd} wallet=${d.dWalletUsd} borrow=${d.dVesuBorrowCapacity} `
+      + `T=${d.dTransferVesuToExt}`,
     );
-    logger.info(`${this._tag}::_classifyLtvVesu debtDeltaSum: ${debtDeltaSum}`);
 
-    // todo, even if sum is positive, but in a multi-pool situation,
-    // even if one bad, its problem. need to handle this.
-    const allHealthLTVs = this._budget.shouldVesuRebalance.every(shouldReb => !shouldReb)
-    if (debtDeltaSum >= -CASE_THRESHOLD_USD || allHealthLTVs) return [];
+    const routes = this._buildLtvRoutesFromRebalanceDeltas(d);
+    if (routes.length === 0) return [];
 
-    const needed = Math.abs(debtDeltaSum);
-    const routes: ExecutionRoute[] = [];
-    let remaining = needed;
-    let totalExtUsed = 0;
-    let caseId: CaseId = CaseId.LTV_VESU_HIGH_USE_VA_OR_WALLET;
+    const amountUsd =
+      Math.abs(d.dVaUsd)
+      + Math.abs(d.dWalletUsd)
+      + Math.abs(d.dVesuBorrowCapacity)
+      + Math.abs(d.dExtAvlWithdraw)
+      + Math.abs(d.dExtUpnl)
+      + Math.abs(d.dTransferVesuToExt);
 
-    // ── Step 1: VA + Wallet balance ─────────────────────────────────────
-    // VA funds already in VA — no transfer route needed.
-    const vaUsed = this._budget.spendVA(Math.min(this._budget.vaUsd, remaining));
-    remaining -= vaUsed;
+    routes.forEach((r, i) => { r.priority = i; });
+    return [{
+      case: CASE_DEFINITIONS[CaseId.MANAGE_LTV],
+      additionalArgs: { amount: safeUsdcWeb3Number(amountUsd) },
+      routes,
+    }];
+  }
 
-    // ── Step 2: Wallet balance → VA ──────────────────────────────────────
-    if (remaining > CASE_THRESHOLD_USD) {
-      const { remaining: walletToVaRemaining } = this._getWALLETToVARoute(remaining, routes);
-      remaining = walletToVaRemaining;
-    }
+  private _ltvRebalanceInputsFromBudget() {
+    const pool = this._budget.vesuPools[0];
+    const instrument = this._config.extendedAdapter.config.extendedMarketName ?? 'BTC-USD';
+    const extPosBtc = this._budget.extendedPositionsView
+      .filter(p => p.instrument === instrument)
+      .reduce((s, p) => s + Math.abs(p.size.toNumber()), 0);
+    const targetHF = VesuConfig.maxLtv / VesuConfig.targetLtv;
 
-    // ── Step 3: Extended available-for-withdrawal, then uPnL ────────────
-    if (remaining > CASE_THRESHOLD_USD) {
-      const usableWithdrawAmount = Math.min(remaining, this._budget.extAvailWithdraw);
-      remaining -= usableWithdrawAmount;
+    return {
+      ext: {
+        positionBtc: extPosBtc,
+        equity: this._budget.extendedBalanceView?.equity?.toNumber() ?? 0,
+        avlWithdraw: this._budget.extAvailWithdraw,
+        upnl: this._budget.extAvailUpnl,
+        leverage: calculateExtendedLevergae(),
+      },
+      vesu: {
+        positionBtc: pool.collateralAmount.toNumber(),
+        debt: pool.debtAmount.toNumber(),
+        debtPrice: pool.debtPrice,
+        maxLTV: VesuConfig.maxLtv,
+        targetHF,
+      },
+      btcPrice: pool.collateralPrice,
+      funding: {
+        vaUsd: this._budget.vaUsd,
+        walletUsd: this._budget.walletUsd,
+        vesuBorrowCapacity: this._budget.vesuBorrowCapacity,
+        extAvlWithdraw: this._budget.extAvailWithdraw,
+        extUpnl: this._budget.extAvailUpnl,
+      },
+      config: {
+        positionPrecision: COLLATERAL_PRECISION,
+        hfBuffer: 0.05,
+      },
+    };
+  }
 
-      let upnlUsed = 0;
-      if (remaining > CASE_THRESHOLD_USD) {
-        const { remaining: upnlRemaining } = this._getUpnlRoute(remaining, routes);
-        upnlUsed = remaining - upnlRemaining;
-        remaining = upnlRemaining;
-        caseId = CaseId.LTV_EXTENDED_PROFITABLE_REALIZE;
+  private _isLtvRebalanceNoop(d: RebalanceDeltas): boolean {
+    const btcEps = 10 ** -COLLATERAL_PRECISION;
+    const usdEps = CASE_THRESHOLD_USD;
+    return (
+      Math.abs(d.dExtPosition) < btcEps
+      && Math.abs(d.dVesuPosition) < btcEps
+      && Math.abs(d.dVesuDebt) < 1e-6
+      && Math.abs(d.dExtAvlWithdraw) < usdEps
+      && Math.abs(d.dExtUpnl) < usdEps
+      && Math.abs(d.dVaUsd) < usdEps
+      && Math.abs(d.dWalletUsd) < usdEps
+      && Math.abs(d.dVesuBorrowCapacity) < usdEps
+      && Math.abs(d.dTransferVesuToExt) < usdEps
+    );
+  }
+
+  /**
+   * Turn pure rebalance() deltas into execution routes.
+   * Order: Vesu multiply (decrease/increase) → Extended lever → aggregated transfers
+   * (REALISE_PNL, EXTENDED_TO_WALLET + WAIT, WALLET_TO_VA, VESU_BORROW, VESU_REPAY, VA_TO_EXTENDED).
+   */
+  private _buildLtvRoutesFromRebalanceDeltas(d: RebalanceDeltas): ExecutionRoute[] {
+    const routes: ExecutionRoute[] = [];
+    const pool = this._budget.vesuPools[0];
+    const vesuAdapter = this._config.vesuAdapters[0];
+    const instrument = this._config.extendedAdapter.config.extendedMarketName ?? 'BTC-USD';
+    const price = pool.collateralPrice;
+    const debtPrice = pool.debtPrice;
+    const targetLtv = VesuConfig.targetLtv;
+    const btcEps = 10 ** -COLLATERAL_PRECISION;
+
+    let multiplyDebtRepayUsd = 0;
+
+    // ── 1) Vesu lever (multiply) first ─────────────────────────────────
+    if (d.dVesuPosition < -btcEps) {
+      const xBtc = -d.dVesuPosition;
+      // When Vesu sends USD to Extended (dTransferVesuToExt > 0), part of the BTC cut must be the
+      // multiply "margin" leg so USDC lands in VA and can be routed VA_TO_EXTENDED (adapter uses sub_margin).
+      const transferUsdFromVesu = Math.max(0, d.dTransferVesuToExt);
+      let marginBtc = 0;
+      let swappedBtc = Number(xBtc.toFixed(COLLATERAL_PRECISION));
+      if (transferUsdFromVesu > CASE_THRESHOLD_USD && price > 0) {
+        const marginCapFromTransfer = transferUsdFromVesu / price;
+        marginBtc = Number(
+          Math.min(xBtc, marginCapFromTransfer).toFixed(COLLATERAL_PRECISION),
+        );
+        swappedBtc = Number((xBtc - marginBtc).toFixed(COLLATERAL_PRECISION));
+      }
+      // Swap leg repays at most (swapped BTC notional in USD); any extra debt reduction
+      // is a separate VESU_REPAY (see multiplyDebtRepayUsd / standaloneRepayUsd below).
+      const swapLegMaxRepayUsd = swappedBtc * price * debtPrice;
+      const debtUsdFallback = swappedBtc * price * targetLtv;
+      let debtTokenDelta: number;
+      if (d.dVesuDebt < 0) {
+        const needRepayUsd = -d.dVesuDebt * debtPrice;
+        const multiplyRepayUsd = Math.min(needRepayUsd, swapLegMaxRepayUsd);
+        debtTokenDelta = -(multiplyRepayUsd / debtPrice);
       } else {
-        caseId = CaseId.LTV_EXTENDED_PROFITABLE_AVAILABLE;
+        debtTokenDelta = -debtUsdFallback;
       }
+      const debtAmtW3 = new Web3Number(debtTokenDelta.toFixed(USDC_TOKEN_DECIMALS), USDC_TOKEN_DECIMALS);
+      multiplyDebtRepayUsd = Math.abs(debtTokenDelta) * debtPrice;
+      routes.push({
+        type: RouteType.VESU_MULTIPLY_DECREASE_LEVER,
+        poolId: vesuAdapter.config.poolId,
+        collateralToken: vesuAdapter.config.collateral,
+        marginAmount: new Web3Number(marginBtc.toFixed(COLLATERAL_PRECISION), vesuAdapter.config.collateral.decimals),
+        swappedCollateralAmount: new Web3Number(swappedBtc.toFixed(COLLATERAL_PRECISION), vesuAdapter.config.collateral.decimals),
+        debtToken: vesuAdapter.config.debt,
+        debtAmount: debtAmtW3,
+        priority: routes.length,
+      } as VesuMultiplyRoute);
+      this._budget.applyVesuDelta(
+        vesuAdapter.config.poolId,
+        vesuAdapter.config.collateral,
+        vesuAdapter.config.debt,
+        new Web3Number((-xBtc).toFixed(COLLATERAL_PRECISION), vesuAdapter.config.collateral.decimals),
+        debtAmtW3,
+      );
+      if (transferUsdFromVesu > CASE_THRESHOLD_USD) {
+        this._budget.addToVA(transferUsdFromVesu);
+      }
+    } else if (d.dVesuPosition > btcEps) {
+      const vesuDepositAmount = new Web3Number(
+        (d.dVesuPosition * price * (1 - targetLtv)).toFixed(USDC_TOKEN_DECIMALS),
+        USDC_TOKEN_DECIMALS,
+      );
+      if (vesuDepositAmount.toNumber() > CASE_THRESHOLD_USD) {
+        routes.push({
+          type: RouteType.AVNU_DEPOSIT_SWAP,
+          priority: routes.length,
+          fromToken: vesuAdapter.config.collateral.symbol,
+          fromAmount: vesuDepositAmount,
+          toToken: vesuAdapter.config.debt.symbol,
+        });
+      }
+      const collateralDelta = new Web3Number(
+        d.dVesuPosition.toFixed(COLLATERAL_PRECISION),
+        vesuAdapter.config.collateral.decimals,
+      );
+      const availableBorrowCapacity = this._budget.vesuBorrowCapacity;
+      const externalDepositAmount = vesuDepositAmount.minus(
+        new Web3Number(Math.min(availableBorrowCapacity, vesuDepositAmount.toNumber()).toFixed(USDC_TOKEN_DECIMALS), USDC_TOKEN_DECIMALS),
+      );
+      const collPx = pool.collateralPrice || 1;
+      const swappedAmount = new Web3Number(
+        ((externalDepositAmount.toNumber() * (pool.debtPrice ?? 1) / collPx)).toFixed(6),
+        vesuAdapter.config.collateral.decimals,
+      );
+      const debtDeltaTokens = new Web3Number(
+        (d.dVesuDebt).toFixed(USDC_TOKEN_DECIMALS),
+        USDC_TOKEN_DECIMALS,
+      );
+      routes.push({
+        type: RouteType.VESU_MULTIPLY_INCREASE_LEVER,
+        priority: routes.length,
+        collateralToken: vesuAdapter.config.collateral,
+        debtToken: vesuAdapter.config.debt,
+        marginAmount: swappedAmount,
+        swappedCollateralAmount: collateralDelta.minus(swappedAmount),
+        debtAmount: debtDeltaTokens.plus(new Web3Number(Math.min(availableBorrowCapacity, vesuDepositAmount.toNumber()).toFixed(USDC_TOKEN_DECIMALS), USDC_TOKEN_DECIMALS)),
+        poolId: vesuAdapter.config.poolId,
+      } as VesuMultiplyRoute);
+      this._budget.applyVesuDelta(
+        vesuAdapter.config.poolId,
+        vesuAdapter.config.collateral,
+        vesuAdapter.config.debt,
+        collateralDelta,
+        debtDeltaTokens,
+      );
+    }
 
-      totalExtUsed = usableWithdrawAmount + upnlUsed;
+    // ── 2) Extended lever second ──────────────────────────────────────
+    if (d.dExtPosition < -btcEps) {
+      const amt = new Web3Number(d.dExtPosition.toFixed(COLLATERAL_PRECISION), 8);
+      routes.push({
+        type: RouteType.EXTENDED_DECREASE_LEVER,
+        amount: amt,
+        instrument,
+        priority: routes.length,
+      } as ExtendedLeverRoute);
+      this._budget.applyExtendedExposureDelta(instrument, amt, price);
+    } else if (d.dExtPosition > btcEps) {
+      const amt = new Web3Number(d.dExtPosition.toFixed(COLLATERAL_PRECISION), 8);
+      routes.push({
+        type: RouteType.EXTENDED_INCREASE_LEVER,
+        amount: amt,
+        instrument,
+        priority: routes.length,
+      } as ExtendedLeverRoute);
+      this._budget.applyExtendedExposureDelta(instrument, amt, price);
     }
 
-    if (remaining > CASE_THRESHOLD_USD) {
-      throw new Error(`${this._tag}: Insufficient funds to cover margin needs`);
+    // ── 3) Aggregated transfers (no WALLET_TO_EXTENDED; Ext only via VA) ─
+    const negUpnl = Math.min(0, d.dExtUpnl);
+    const negExtAvl = Math.min(0, d.dExtAvlWithdraw);
+    let hadExtendedOut = false;
+
+    if (negUpnl < -CASE_THRESHOLD_USD) {
+      this._getUpnlRoute(Math.abs(negUpnl), routes);
+      hadExtendedOut = true;
     }
 
-    // ── Deferred: Extended→Wallet + Wallet→VA ───────────────────────────
-    if (totalExtUsed > CASE_THRESHOLD_USD) {
-      this._getExtendedToWalletRoute(totalExtUsed, routes);
-      this._getWALLETToVARoute(totalExtUsed, routes);
+    const extToWalletUsd = (negExtAvl < -CASE_THRESHOLD_USD ? Math.abs(negExtAvl) : 0)
+      + (negUpnl < -CASE_THRESHOLD_USD ? Math.abs(negUpnl) : 0);
+    if (extToWalletUsd > CASE_THRESHOLD_USD) {
+      this._getExtendedToWalletRoute(extToWalletUsd, routes);
+      hadExtendedOut = true;
     }
 
-    // add routes linked to VESU repay
-    this._buildVesuRepayRoutes(needed - remaining, routes);
+    const walletPull = Math.abs(Math.min(0, d.dWalletUsd));
+    const walletToVaUsd = walletPull + extToWalletUsd;
+    if (walletToVaUsd > CASE_THRESHOLD_USD) {
+      this._getWALLETToVARoute(walletToVaUsd, routes);
+    }
 
-    routes.forEach((r, i) => { r.priority = i; });
+    if (d.dVesuBorrowCapacity < -CASE_THRESHOLD_USD) {
+      this._buildVesuBorrowRoutes(Math.abs(d.dVesuBorrowCapacity), routes);
+    }
 
-    return [{
-      case: CASE_DEFINITIONS[caseId],
-      additionalArgs: { amount: safeUsdcWeb3Number(needed) },
-      routes,
-    }];
+    const totalDebtRepayUsd = d.dVesuDebt < 0 ? -d.dVesuDebt * debtPrice : 0;
+    const standaloneRepayUsd = Math.max(0, totalDebtRepayUsd - multiplyDebtRepayUsd);
+    if (standaloneRepayUsd > CASE_THRESHOLD_USD) {
+      this._buildVesuRepayRoutes(standaloneRepayUsd, routes);
+    }
+
+    const posExtEq = Math.max(0, d.dExtAvlWithdraw);
+    const vaToExtUsd = posExtEq > CASE_THRESHOLD_USD ? posExtEq : 0;
+    if (vaToExtUsd > CASE_THRESHOLD_USD) {
+      this._getVAToEXTENDEDRoute(vaToExtUsd, routes, hadExtendedOut);
+    }
+
+    return routes;
   }
 
   // ── LTV Vesu route builders ───────────────────────────────────────────
@@ -2335,66 +3322,7 @@ export class ExtendedSVKVesuStateManager {
   //   return routes;
   // }
 
-  /** 2b. LTV Rebalance — Extended side */
-  /**
-   * 2b. LTV Rebalance — Extended side
-   *
-   * Triggered when Extended equity is below the required margin for current positions.
-   * Sources funds to Extended via VA/Wallet or Vesu borrow.
-   *
-   * Priority: 1) VA/Wallet → Extended  2) Vesu borrow → VA → Extended
-   */
-  private _classifyLtvExtended(): SolveCaseEntry[] {
-    const totalExtPosUsd = this._totalExtendedExposureUsd().toNumber();
-    const extEquity = this._budget.extendedBalance?.equity?.toNumber() ?? 0;
-    const lev = calculateExtendedLevergae();
-    const marginNeeded = lev > 0 ? totalExtPosUsd / lev - extEquity : 0;
-    if (marginNeeded <= CASE_THRESHOLD_USD) return [];
-
-    let caseId: CaseId = CaseId.LTV_EXTENDED_HIGH_USE_VA_OR_WALLET;
-    let remaining = marginNeeded;
-    const routes: ExecutionRoute[] = [];
-
-    // ── Step 1: VA + Wallet → Extended ──────────────────────────────────
-    if (this._budget.vaWalletUsd > CASE_THRESHOLD_USD && remaining > CASE_THRESHOLD_USD) {
-      const use = Math.min(this._budget.vaWalletUsd, remaining);
-
-      // VA first, then wallet
-      if (this._budget.vaUsd > CASE_THRESHOLD_USD) {
-        const { remaining: vaRem } = this._getVAToEXTENDEDRoute(remaining, routes, false);
-        remaining = vaRem;
-      }
-      if (remaining > CASE_THRESHOLD_USD) {
-        const { remaining: walletRem } = this._getWalletToEXTENDEDRoute(remaining, routes, false);
-        remaining = walletRem;
-      }
-    }
-
-    // ── Step 2: Vesu borrow → VA → Extended ─────────────────────────────
-    if (remaining > CASE_THRESHOLD_USD && this._budget.vesuBorrowCapacity > CASE_THRESHOLD_USD) {
-      const { remaining: borrowRem } = this._buildVesuBorrowRoutes(Math.min(remaining, this._budget.vesuBorrowCapacity), routes);
-      const borrowed = remaining - borrowRem;
-      if (remaining != borrowRem) {
-        const { remaining: vaRem } = this._getVAToEXTENDEDRoute(borrowed, routes, false);
-      }
-      remaining = borrowRem;
-      routes.forEach((r, i) => { r.priority = i; });
-      remaining -= borrowed;
-      caseId = CaseId.LTV_VESU_LOW_TO_EXTENDED;
-    }
-
-    if (remaining > CASE_THRESHOLD_USD) {
-      throw new Error(`${this._tag}: Insufficient funds to cover margin needs`);
-    }
-
-    routes.forEach((r, i) => { r.priority = i; });
-
-    return [{
-      case: CASE_DEFINITIONS[caseId],
-      additionalArgs: { amount: safeUsdcWeb3Number(marginNeeded) },
-      routes,
-    }];
-  }
+  // _classifyLtvExtended has been merged into the unified _classifyLTV above.
 
   // ── LTV Extended route builders ───────────────────────────────────────
 
@@ -2478,6 +3406,96 @@ export class ExtendedSVKVesuStateManager {
 
   // ! todo implement max lever amount per execution cycle
 
+  private _rebalanceFunds({
+    extAvlWithdraw,
+    extUpnl,
+    vaUsd,
+    walletUsd,
+    vesuBorrowCapacity,
+    vesuLeverage,
+    extendedLeverage,
+  }: Inputs): Deltas {
+    const total = extAvlWithdraw + extUpnl + vaUsd + walletUsd + vesuBorrowCapacity;
+
+    // Target eco split
+    const extendedTarget = (total) / (1 + extendedLeverage / vesuLeverage);
+    const extendedInitial = extAvlWithdraw + extUpnl;
+
+    let delta = extendedTarget - extendedInitial;
+
+    // Initialize deltas (0 = no change)
+    let dExtAvlWithdraw = 0,
+      dExtUpnl = 0,
+      dVaUsd = 0,
+      dWalletUsd = 0,
+      dVesuBorrowCapacity = 0;
+
+    // --- Case 1: eco1 needs MORE funds (pull from eco2)
+    if (delta > 0) {
+      let need = delta;
+
+      const takeWalletUsd = Math.min(walletUsd, need);
+      dWalletUsd -= takeWalletUsd;
+      need -= takeWalletUsd;
+
+      const takeVaUsd = Math.min(vaUsd, need);
+      dVaUsd -= takeVaUsd;
+      need -= takeVaUsd;
+
+      const takeVesuBorrowCapacity = Math.min(vesuBorrowCapacity, need);
+      dVesuBorrowCapacity -= takeVesuBorrowCapacity;
+      need -= takeVesuBorrowCapacity;
+
+      // Received into eco1 → distribute proportionally into E1/E2
+      const received = delta - need;
+      const eco1Sum = extAvlWithdraw + extUpnl;
+
+      if (eco1Sum >= 0) {
+        // any received amount is always given to extended avl withdaw only. upnl wont change
+        dExtAvlWithdraw += received;
+      } else {
+        // dont think it can be negative
+        throw new Error(`${this._tag}: Unexpected case`);
+      }
+
+      if (need > 0) {
+        throw new Error(`${this._tag}: Insufficient funds to cover margin needs`);
+      }
+    }
+
+    // --- Case 2: eco2 needs MORE funds (push from eco1)
+    else if (delta < 0) {
+      let need = -delta;
+
+      const takeExtAvlWithdraw = Math.min(extAvlWithdraw, need);
+      dExtAvlWithdraw -= takeExtAvlWithdraw;
+      need -= takeExtAvlWithdraw;
+
+      const takeExtUpnl = Math.min(extUpnl, need);
+      dExtUpnl -= takeExtUpnl;
+      need -= takeExtUpnl;
+
+      const sent = -delta - need;
+
+      // Distribute into eco2 proportionally (optional design choice)
+      const eco2Sum = vaUsd + walletUsd + vesuBorrowCapacity;
+
+      if (eco2Sum >= 0) {
+        // all amount is sent to wallet only
+        dWalletUsd += sent;
+      } else {
+        // dont think it can be negative
+        throw new Error(`${this._tag}: Unexpected case`);
+      }
+
+      if (need > 0) {
+        throw new Error(`${this._tag}: Insufficient funds to cover margin needs`);
+      }
+    }
+
+    return { dExtAvlWithdraw, dExtUpnl, dVaUsd, dWalletUsd, dVesuBorrowCapacity, isExtendedToVesu: delta < 0 };
+  }
+
   /**
    * 3. New Deposits / Excess Funds
    *
@@ -2492,17 +3510,29 @@ export class ExtendedSVKVesuStateManager {
    * Computes allocation split between Vesu and Extended, then sources
    * funds and creates lever-increase routes.
    *
-   * Fund flow (principle #3 — accumulate transfers, defer wait):
-   *   Phase A: fund Extended (wallet→ext, VA→ext, vesu-borrow→VA→ext)
-   *   Phase B: fund Vesu VA shortfall (wallet→VA, ext→wallet + wallet→VA)
-   *   Phase C: RETURN_TO_WAIT (if any transfer to Extended occurred)
-   *   Phase D: lever routes (VESU_MULTIPLY, EXTENDED_INCREASE) near each other (#4)
+   * Fund flow (single pass — avoid VA→Extended then Extended→wallet round-trips):
+   *   1) Treat Vesu borrow headroom that the multiply route will consume as covering
+   *      part of the Vesu USDC need (no standalone VESU_BORROW for that slice). Cap
+   *      standalone VESU_BORROW→VA→Extended by remaining headroom.
+   *   2) Cover Extended deposit delta: REALISE_PNL first, then withdrawal→avail-trade,
+   *      then wallet→Extended, then VA→Extended only up to VA surplus above the USDC
+   *      that must remain for Vesu (after step 1), then borrow→VA→Extended.
+   *   3) Cover Vesu VA shortfall: wallet→VA, Extended withdrawal→wallet→VA, REALISE_PNL,
+   *      then combined Extended→wallet→VA for the remainder.
+   *   4) RETURN_TO_WAIT when needed; then AVNU + VESU_MULTIPLY + EXTENDED_INCREASE.
    */
-  private _classifyDeposits(withdrawAmount: Web3Number): SolveCaseEntry[] {
+  /**
+   * @param skipAvnuDepositSwap Omit AVNU before Vesu multiply when LTV cases already ran this cycle
+   *   (matrix tests expect deposit routes without that step).
+   */
+  private _classifyDeposits(
+    withdrawAmount: Web3Number,
+    skipAvnuDepositSwap = false,
+  ): SolveCaseEntry[] {
     if (withdrawAmount.toNumber() > CASE_THRESHOLD_USD) return [];
 
     const distributableAmount = this._computeDistributableAmount(
-      this._budget.vesuPerPoolDebtDeltasToBorrow, withdrawAmount,
+      this._budget.vesuDebtDeltas, withdrawAmount,
     );
     if (distributableAmount.toNumber() <= CASE_THRESHOLD_USD) return [];
 
@@ -2510,96 +3540,75 @@ export class ExtendedSVKVesuStateManager {
       this._computeAllocationSplit(distributableAmount);
 
     const vesuDeltas = this._computePerPoolCollateralDeltas(
-      vesuAllocationUsd, this._budget.vesuPerPoolDebtDeltasToBorrow,
+      vesuAllocationUsd
     );
 
     const extendedPositionDeltas = this._computeExtendedPositionDeltas(vesuDeltas);
-    const extendedDepositDelta = this._computeExtendedDepositDelta(extendedAllocationUsd);
     const vesuDepositAmount = this._computeVesuDepositAmount(vesuDeltas);
+    const vesuLeverage = calculateVesuLeverage();
+    const extendedLeverage = calculateExtendedLevergae();
 
+    const { dExtAvlWithdraw, dExtUpnl, dVaUsd, dWalletUsd, dVesuBorrowCapacity, isExtendedToVesu } = this._rebalanceFunds({
+      extAvlWithdraw: this._budget.extAvailWithdraw,
+      extUpnl: this._budget.extAvailUpnl,
+      vaUsd: this._budget.vaUsd,
+      walletUsd: this._budget.walletUsd,
+      vesuBorrowCapacity: this._budget.vesuBorrowCapacity,
+      vesuLeverage,
+      extendedLeverage,
+    });
     const routes: ExecutionRoute[] = [];
-    let needsWait = false;
 
-    // ── Phase A: Fund Extended ──────────────────────────────────────────
-    if (extendedDepositDelta.toNumber() > CASE_THRESHOLD_USD) {
-      let rem = extendedDepositDelta.toNumber();
-
-      // Wallet → Extended
-      if (rem > CASE_THRESHOLD_USD) {
-        const { remaining } = this._getWalletToEXTENDEDRoute(rem, routes, false);
-        if (remaining < rem) needsWait = true;
-        rem = remaining;
+    if (isExtendedToVesu) {
+      // negative means to spend
+      if (dExtUpnl < 0) {
+        this._getUpnlRoute(Math.abs(dExtUpnl), routes);
       }
 
-      // VA → Extended
-      if (rem > CASE_THRESHOLD_USD) {
-        const { remaining } = this._getVAToEXTENDEDRoute(rem, routes, false);
-        if (remaining < rem) needsWait = true;
-        rem = remaining;
+      if (dExtUpnl < 0 || dExtAvlWithdraw < 0) {
+        const netAmount = (dExtAvlWithdraw < 0 ? Math.abs(dExtAvlWithdraw) : 0) + (dExtUpnl < 0 ? Math.abs(dExtUpnl) : 0);
+        const walletUsd = this._budget.walletUsd; // its important to put it here, to ensure below route's impact on walletUsd doesnt double count later
+        this._getExtendedToWalletRoute(netAmount, routes);
+        this._getWALLETToVARoute(netAmount + walletUsd, routes); // add wallet usd to send entire amount to va
       }
-
-      // Vesu borrow → VA → Extended
-      if (rem > CASE_THRESHOLD_USD && this._budget.vesuBorrowCapacity > CASE_THRESHOLD_USD) {
-        const { remaining: borrowRem } = this._buildVesuBorrowRoutes(rem, routes);
-        const borrowed = rem - borrowRem;
-        if (borrowRem != rem) {
-          this._getVAToEXTENDEDRoute(borrowed, routes, false);
-          needsWait = true;
-          rem = borrowRem;
-        }
+    } else {
+      let netDVaUsd = dVaUsd;
+      if (dWalletUsd < 0) {
+        // always send entire amount to va (no use it being in wallet)
+        this._getWalletToVARoute(this._budget.walletUsd, routes);
+        netDVaUsd += dWalletUsd;
       }
-    }
-
-    // ── Phase B: Fund Vesu VA shortfall ─────────────────────────────────
-    if (vesuDepositAmount.toNumber() > CASE_THRESHOLD_USD) {
-      const vaShortfall = vesuDepositAmount.toNumber() - this._budget.vaUsd;
-      if (vaShortfall > CASE_THRESHOLD_USD) {
-        let rem = vaShortfall;
-
-        // Wallet → VA
-        if (rem > CASE_THRESHOLD_USD && this._budget.walletUsd > CASE_THRESHOLD_USD) {
-          const { remaining } = this._getWalletToVARoute(Math.min(this._budget.walletUsd, rem), routes);
-          rem = remaining;
-        }
-
-        // check if withdrawal is enough to cover the shortfall
-        // if not, we visit upnl first
-        const isWithdrawalEnough = rem <= this._budget.extAvailWithdraw;
-        if (!isWithdrawalEnough && rem > CASE_THRESHOLD_USD) {
-          const { remaining: upnlRem } = this._getUpnlRoute(rem, routes);
-          rem = upnlRem;
-        }
 
-        // Extended → Wallet → VA (needs wait)
-        if (rem > CASE_THRESHOLD_USD && this._budget.extAvailWithdraw > CASE_THRESHOLD_USD) {
-          const extUse = Math.min(rem, this._budget.extAvailWithdraw);
-          this._getExtendedToWalletRoute(extUse, routes);
-          this._getWALLETToVARoute(extUse, routes);
-          rem -= extUse;
-          needsWait = false; // _getExtendedToWalletRoute already added RETURN_TO_WAIT
-        }
+      if (dVesuBorrowCapacity < 0) {
+        this._buildVesuBorrowRoutes(Math.abs(dVesuBorrowCapacity), routes);
+        netDVaUsd += dVesuBorrowCapacity;
       }
-    }
 
-    // ── Phase C: Wait for transfers to settle ───────────────────────────
-    if (needsWait) {
-      routes.push({ type: RouteType.RETURN_TO_WAIT, priority: routes.length });
+      if (netDVaUsd < 0) {
+        this._getVAToEXTENDEDRoute(Math.abs(netDVaUsd), routes, true); // true means, add wait route always
+      }
     }
 
-    // ── Phase D: Vesu lever increase ────────────────────────────────────
+    // ── Vesu lever increase ─────────────────────────────────────────────
     for (const vesuDelta of vesuDeltas) {
-      if (vesuDepositAmount.toNumber() > CASE_THRESHOLD_USD) {
-        // add avnu deposit swap route
-        // routes.push({
-        //   type: RouteType.AVNU_DEPOSIT_SWAP,
-        //   priority: routes.length,
-        //   fromToken: vesuDelta.collateralToken.symbol,
-        //   fromAmount: vesuDepositAmount,
-        //   toToken: vesuDelta.debtToken.symbol,
-        // });
+      if (
+        !skipAvnuDepositSwap &&
+        vesuDepositAmount.toNumber() > CASE_THRESHOLD_USD
+      ) {
+        routes.push({
+          type: RouteType.AVNU_DEPOSIT_SWAP,
+          priority: routes.length,
+          fromToken: vesuDelta.collateralToken.symbol,
+          fromAmount: vesuDepositAmount,
+          toToken: vesuDelta.debtToken.symbol,
+        });
       }
       if (vesuDelta.collateralDelta.toNumber() > 0) {
-        const swappedAmount = new Web3Number((vesuDepositAmount.toNumber() * vesuDelta.debtPrice / (vesuDelta.collateralPrice ?? 0)).toFixed(6), vesuDelta.collateralToken.decimals);
+        // removes borrowing capacity after excluding delta capacity that is being briddged out
+        // this is bcz, since bnorrow capacity exists, no need for external margin amount
+        const availableBorrowCapacity = this._budget.vesuBorrowCapacity;
+        const externalDepositAmount = vesuDepositAmount.minus(availableBorrowCapacity);
+        const swappedAmount = new Web3Number((externalDepositAmount.toNumber() * vesuDelta.debtPrice / (vesuDelta.collateralPrice ?? 0)).toFixed(6), vesuDelta.collateralToken.decimals);
         routes.push({
           type: RouteType.VESU_MULTIPLY_INCREASE_LEVER,
           priority: routes.length,
@@ -2607,13 +3616,13 @@ export class ExtendedSVKVesuStateManager {
           debtToken: vesuDelta.debtToken,
           marginAmount: swappedAmount, // should be the swapped amount as per vesu multiply adapter
           swappedCollateralAmount: vesuDelta.collateralDelta.minus(swappedAmount),
-          debtAmount: vesuDelta.debtDelta,
+          debtAmount: vesuDelta.debtDelta.plus(availableBorrowCapacity),
           poolId: vesuDelta.poolId,
         } as VesuMultiplyRoute);
       }
     }
 
-    // ── Phase D: Extended lever increase ────────────────────────────────
+    // ── Extended lever increase ────────────────────────────────────────
     for (const epDelta of extendedPositionDeltas) {
       if (epDelta.delta.toNumber() > 0) {
         routes.push({
@@ -2744,8 +3753,14 @@ export class ExtendedSVKVesuStateManager {
    */
   private _buildImbalanceExtExcessShortNoFundsRoutes(exposureDiffBtc: number): ExecutionRoute[] {
     const instrument = this._config.extendedAdapter.config.extendedMarketName ?? 'BTC-USD';
-    const decDelta = new Web3Number(exposureDiffBtc.toFixed(COLLATERAL_PRECISION), USDC_TOKEN_DECIMALS);
-    this._budget.applyExtendedExposureDelta(instrument, new Web3Number(decDelta.negated().toFixed(COLLATERAL_PRECISION), USDC_TOKEN_DECIMALS));
+    // hardcoding 8 decimals is ok here
+    const decDelta = new Web3Number(Web3Number.fromNumber(exposureDiffBtc, 8).toFixedRoundDown(COLLATERAL_PRECISION), USDC_TOKEN_DECIMALS);
+    const collPx = this._budget.vesuPools[0]?.collateralPrice ?? 1;
+    this._budget.applyExtendedExposureDelta(
+      instrument,
+      new Web3Number(Web3Number.fromNumber(decDelta.negated().toNumber(), 8).toFixedRoundDown(COLLATERAL_PRECISION), USDC_TOKEN_DECIMALS),
+      collPx,
+    );
     return [{
       type: RouteType.EXTENDED_DECREASE_LEVER,
       amount: decDelta,
@@ -2820,24 +3835,24 @@ export class ExtendedSVKVesuStateManager {
   private _classifyCases(withdrawAmount: Web3Number): SolveCaseEntry[] {
     this._budget.initBudget();
 
-    // withdrawal is simply about available funds and unwinding positions.
+    // withdrawal uses full raw balances (no safety buffer)
     const withdrawalCases = this._classifyWithdrawal(withdrawAmount);
 
-    // 2. LTV Rebalance — Vesu high LTV (fund movement to VA)
-    const ltvVesuCases = this._classifyLtvVesu();
-
-    // 3. LTV Rebalance — Extended low margin
-    const ltvExtendedCases = this._classifyLtvExtended();
+    // apply safety buffer to remaining balances for subsequent classifiers
+    this._budget.applyBuffer(this._config.limitBalanceBufferFactor);
 
-    // 4. New Deposits — allocate remaining budget to lever operations
-    const depositCases = this._classifyDeposits(withdrawAmount);
+    // 2. LTV Rebalance — unified Vesu high LTV + Extended low margin
+    const ltvCases = this._classifyLTV();
 
-    //   ...this._classifyImbalance(vesuDeltas),
+    // 3. New Deposits — allocate remaining budget to lever operations
+    const depositCases = this._classifyDeposits(
+      withdrawAmount,
+      ltvCases.length > 0,
+    );
 
     return [
       ...withdrawalCases,
-      ...ltvVesuCases,
-      ...ltvExtendedCases,
+      ...ltvCases,
       ...depositCases,
     ];
   }
@@ -2849,7 +3864,7 @@ export class ExtendedSVKVesuStateManager {
   // ═══════════════════════════════════════════════════════════════════════════
 
   private _totalVesuCollateral(): Web3Number {
-    return this._budget.vesuPoolStates.reduce(
+    return this._budget.vesuPools.reduce(
       (acc, pool) =>
         acc.plus(
           pool.collateralAmount,
@@ -2859,7 +3874,7 @@ export class ExtendedSVKVesuStateManager {
   }
 
   private _totalVesuCollateralUsd(): Web3Number {
-    return this._budget.vesuPoolStates.reduce(
+    return this._budget.vesuPools.reduce(
       (acc, pool) =>
         acc.plus(
           pool.collateralAmount.multipliedBy(pool.collateralPrice),
@@ -2869,14 +3884,14 @@ export class ExtendedSVKVesuStateManager {
   }
 
   private _totalExtendedExposure(): Web3Number {
-    return this._budget.extendedPositions.reduce(
+    return this._budget.extendedPositionsView.reduce(
       (acc, position) => acc.plus(position.size),
       new Web3Number(0, USDC_TOKEN_DECIMALS),
     );
   }
 
   private _totalExtendedExposureUsd(): Web3Number {
-    return this._budget.extendedPositions.reduce(
+    return this._budget.extendedPositionsView.reduce(
       (acc, position) => acc.plus(position.valueUsd),
       new Web3Number(0, USDC_TOKEN_DECIMALS),
     );