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

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

@@ -13,7 +13,7 @@ import {
   calculateVesuLeverage,
 } from "../utils/helper";
 import { VesuConfig } from "../utils/config.runtime";
-import { rebalance, type RebalanceDeltas } from "./ltv-imbalance-rebalance-math";
+import { rebalance, routableDrawAmount, type RebalanceDeltas } from "./ltv-imbalance-rebalance-math";
 
 // ─── State types ───────────────────────────────────────────────────────────────
 
@@ -77,6 +77,8 @@ type Deltas = {
   dVaUsd: number;
   dWalletUsd: number;
   dVesuBorrowCapacity: number;
+  finalVaUsd: number;
+  finalExtended: number;
   isExtendedToVesu: boolean;
 };
 
@@ -748,12 +750,12 @@ export class SolveBudget {
   // ── 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).
+   * Idle non-stable {@link StateManagerConfig.assetToken} in the vault allocator.
+   * Null when asset and USDC are the same token (VA idle stablecoin is only in {@link vaultUsdcBalance}).
    */
+  private vaultAssetBalance: TokenBalance | null;
+  /** Idle {@link StateManagerConfig.usdcToken} in the vault allocator (including when it is also the strategy asset). */
   private vaultUsdcBalance: TokenBalance | null;
   private extendedPositions: ExtendedPositionState[];
   private extendedBalance: ExtendedBalanceState | null;
@@ -1037,9 +1039,10 @@ export class SolveBudget {
 
   // ── Derived getters (buffered where applicable) ─────────────────────
 
-  /** Buffered VA USD: strategy-asset slot + optional USDC slot. */
+  /** Buffered VA USD: non-stable asset slot (if any) + USDC slot. */
   get vaUsd(): number {
-    return this.bufferedTokenUsd(this.vaultAssetBalance) + this.bufferedTokenUsd(this.vaultUsdcBalance);
+    // return this.bufferedTokenUsd(this.vaultAssetBalance) + this.bufferedTokenUsd(this.vaultUsdcBalance);
+    return this.bufferedTokenUsd(this.vaultUsdcBalance); // we dont have swap routes and is not correct, to consider asset balance directlyt in strategy
   }
 
   /** Buffered USD in VA strategy-asset bucket only. */
@@ -1047,7 +1050,7 @@ export class SolveBudget {
     return this.bufferedTokenUsd(this.vaultAssetBalance);
   }
 
-  /** Buffered USD in VA USDC bucket (0 when asset === USDC). */
+  /** Buffered USD in VA USDC bucket (includes full VA idle when asset === USDC). */
   get vaUsdcUsd(): number {
     return this.bufferedTokenUsd(this.vaultUsdcBalance);
   }
@@ -1146,9 +1149,15 @@ export class SolveBudget {
     return this.shouldVesuRebalance;
   }
 
-  /** Raw USD in VA (USDC slot + asset slot); spend caps when executing transfers. */
+  /** Raw USD in VA (USDC slot + non-stable asset slot when distinct); spend caps when executing transfers. */
   private _vaRawUsd(): number {
-    return this._rawTokenUsd(this.vaultUsdcBalance) + this._rawTokenUsd(this.vaultAssetBalance);
+    // return this._rawTokenUsd(this.vaultUsdcBalance) + this._rawTokenUsd(this.vaultAssetBalance);
+    return this._rawTokenUsd(this.vaultUsdcBalance); // we dont have swap routes and is not correct, to consider asset balance directlyt in strategy
+  }
+
+  /** VA liquidity usable for repay / {@link spendVaRawUsd} (matches nominal balances after any {@link applyBuffer} scaling). */
+  get vaRawUsd(): number {
+    return this._vaRawUsd();
   }
 
   private _walletRawUsd(): number {
@@ -1235,7 +1244,8 @@ export class SolveBudget {
       rem -= fromUsdc;
     }
     if (rem > 0 && this.vaultAssetBalance) {
-      this._deductUsdFromTokenBalance(this.vaultAssetBalance, rem);
+      // this._deductUsdFromTokenBalance(this.vaultAssetBalance, rem);
+      throw new Error(`Not implemented: spendVA with vaultAssetBalance`);
     }
     this._recomputeUnusedBalance();
     logger.debug(`SolveBudget::spendVA usedRaw=${usedRaw}, vaUsd=${this.vaUsd}, totalUnused=${this.totalUnused}`);
@@ -1247,7 +1257,8 @@ export class SolveBudget {
    */
   spendVaRawUsd(rawUsdDesired: number): number {
     const capRaw =
-      this._rawTokenUsd(this.vaultUsdcBalance) + this._rawTokenUsd(this.vaultAssetBalance);
+      // this._rawTokenUsd(this.vaultUsdcBalance) + this._rawTokenUsd(this.vaultAssetBalance);
+      this._rawTokenUsd(this.vaultUsdcBalance); // we dont have swap routes and is not correct, to consider asset balance directlyt in strategy
     const usedRaw = Math.min(capRaw, Math.max(0, rawUsdDesired));
     if (usedRaw <= CASE_THRESHOLD_USD) return 0;
     let rem = usedRaw;
@@ -1257,7 +1268,8 @@ export class SolveBudget {
       rem -= fromUsdc;
     }
     if (rem > 0 && this.vaultAssetBalance) {
-      this._deductUsdFromTokenBalance(this.vaultAssetBalance, rem);
+      // this._deductUsdFromTokenBalance(this.vaultAssetBalance, rem);
+      throw new Error(`Not implemented: spendVaRawUsd with vaultAssetBalance`);
     }
     this._recomputeUnusedBalance();
     logger.debug(`SolveBudget::spendVaRawUsd usedRaw=${usedRaw}, vaUsd=${this.vaUsd}, totalUnused=${this.totalUnused}`);
@@ -1273,7 +1285,8 @@ export class SolveBudget {
     if (this.vaultUsdcBalance) {
       this._addUsdToTokenBalance(this.vaultUsdcBalance, rawUsd);
     } else if (this.vaultAssetBalance) {
-      this._addUsdToTokenBalance(this.vaultAssetBalance, rawUsd);
+      // this._addUsdToTokenBalance(this.vaultAssetBalance, rawUsd);
+      throw new Error(`Not implemented: addToVA with vaultAssetBalance`);
     }
     this._recomputeUnusedBalance();
     logger.debug(`SolveBudget::addToVA rawUsd=${rawUsd}, vaUsd=${this.vaUsd}, totalUnused=${this.totalUnused}`);
@@ -1316,7 +1329,7 @@ export class SolveBudget {
     if (isSpend) {
       const capRaw = this.extendedBalance?.availableForWithdrawal?.toNumber() ?? 0;
       const useRaw = Math.min(capRaw, desiredRaw);
-      if (useRaw <= CASE_THRESHOLD_USD) return 0;
+      if (useRaw <= 0) return 0;
       rawDelta = -useRaw;
     } else {
       rawDelta = desiredRaw;
@@ -1338,7 +1351,7 @@ export class SolveBudget {
     if (isSpend) {
       const capRaw = this.extendedBalance?.unrealisedPnl?.toNumber() ?? 0;
       const useRaw = Math.min(capRaw, desiredRaw);
-      if (useRaw <= CASE_THRESHOLD_USD) return 0;
+      if (useRaw <= 0) return 0;
       rawDelta = -useRaw;
     } else {
       rawDelta = desiredRaw;
@@ -1355,10 +1368,12 @@ export class SolveBudget {
   }
 
   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;
+    const usedWd = this._updateExtAvailWithdraw(rawDesired, true);
+    const tookWd = Math.abs(usedWd);
+    const rem = rawDesired - tookWd;
+    const usedUpnl = rem > 0 ? this._updateExtAvailUpnl(rem, true) : 0;
+    logger.debug(`SolveBudget::updateExtAvailTrade rawSum=${usedWd + usedUpnl}, extAvailTrade=${this.extAvailTrade}, totalUnused=${this.totalUnused}`);
+    return usedWd + usedUpnl;
   }
 
   // simply reduces available amounts, but maintains equity and balance.
@@ -1801,8 +1816,9 @@ export class ExtendedSVKVesuStateManager {
     ]);
 
     logger.verbose(
-      `${this._tag}::_refresh VA asset ${vaultAssetBalance.token.symbol}=$${vaultAssetBalance.usdValue.toFixed(2)}` +
-      `${vaultUsdcBalance ? `, VA USDC=$${vaultUsdcBalance.usdValue.toFixed(2)}` : ""}` +
+      `${this._tag}::_refresh ` +
+      `${vaultAssetBalance ? `VA asset ${vaultAssetBalance.token.symbol}=$${vaultAssetBalance.usdValue.toFixed(2)}, ` : ""}` +
+      `VA USDC=${vaultUsdcBalance.usdValue.toFixed(2)}` +
       `, wallet=${walletBalance.usdValue}`,
     );
     const unusedBalance = this._computeUnusedBalances(
@@ -1839,6 +1855,7 @@ export class ExtendedSVKVesuStateManager {
       },
       vesuPoolStates,
     });
+    this._budget.logStateSummary();
 
     const totalUnusedUsd = unusedBalance.reduce(
       (acc, b) => acc + b.usdValue,
@@ -1846,10 +1863,10 @@ export class ExtendedSVKVesuStateManager {
     );
     logger.info(
       `${this._tag}::_refresh completed — ` +
-      `unusedBalances: ${unusedBalance.length} tokens, ` +
+      `unusedBalances: ${unusedBalance.length} tokens [${unusedBalance.map((b) => `${b.token.symbol}=$${b.usdValue.toFixed(2)}`).join(', ')}], ` +
       `totalUnusedUsd: ${totalUnusedUsd.toFixed(2)}, ` +
-      `extendedPositions: ${extendedPositions.length}, ` +
-      `vesuPools: ${vesuPoolStates.length} - ` +
+      `extendedPositions: ${extendedPositions.length} [${extendedPositions.map((p) => `${p.instrument}=${p.size.toFixed(6)} ${p.side}, ${p.valueUsd.toFixed(6)} ${p.instrument}`).join(', ')}], ` +
+      `vesuPools: ${vesuPoolStates.length} [${vesuPoolStates.map((p) => `${p.poolId.shortString()}=${p.debtAmount.toFixed(6)} ${p.debtToken.symbol}, ${p.collateralAmount.toFixed(6)} ${p.collateralToken.symbol}`).join(', ')}], ` +
       `availableForTrade: ${extendedBalance?.availableForTrade.toNumber()} - ` +
       `availableForWithdrawal: ${extendedBalance?.availableForWithdrawal.toNumber()} - ` +
       `unrealisedPnl: ${extendedBalance?.unrealisedPnl.toNumber()} - ` +
@@ -1861,15 +1878,19 @@ 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). */
+  /** True when strategy asset and USDC share one token — VA idle balance is tracked as USDC, not as asset. */
   private _vaultAssetAndUsdcAreSameToken(): boolean {
     return this._config.assetToken.address.eq(this._config.usdcToken.address);
   }
 
   /**
-   * Reads the {@link StateManagerConfig.assetToken} balance idle in the vault allocator.
+   * Reads idle {@link StateManagerConfig.assetToken} in the vault allocator when it differs from USDC.
+   * When asset and USDC are the same token, returns null (that balance is reported via {@link _fetchVaultAllocatorUsdcBalanceIfDistinct} only).
    */
-  private async _fetchVaultAllocatorAssetBalance(): Promise<TokenBalance> {
+  private async _fetchVaultAllocatorAssetBalance(): Promise<TokenBalance | null> {
+    if (this._vaultAssetAndUsdcAreSameToken()) {
+      return null;
+    }
     const { assetToken, vaultAllocator, networkConfig, pricer } = this._config;
     const balance = await new ERC20(networkConfig).balanceOf(
       assetToken.address,
@@ -1884,12 +1905,9 @@ export class ExtendedSVKVesuStateManager {
   }
 
   /**
-   * 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).
+   * Reads {@link StateManagerConfig.usdcToken} idle in the vault allocator (always — distinct asset or USDC-as-asset).
    */
-  private async _fetchVaultAllocatorUsdcBalanceIfDistinct(): Promise<TokenBalance | null> {
-    if (this._vaultAssetAndUsdcAreSameToken()) return null;
-
+  private async _fetchVaultAllocatorUsdcBalanceIfDistinct(): Promise<TokenBalance> {
     const { usdcToken, vaultAllocator, networkConfig, pricer } = this._config;
     const balance = await new ERC20(networkConfig).balanceOf(
       usdcToken.address,
@@ -1906,12 +1924,12 @@ export class ExtendedSVKVesuStateManager {
   }
 
   /**
-   * Merges vault-allocator asset, optional vault-allocator USDC, and operator wallet
+   * Merges vault-allocator asset (if any), vault-allocator USDC, and operator wallet
    * balances into entries keyed by token address.
    */
   private _computeUnusedBalances(
-    vaultAssetBalance: TokenBalance,
-    vaultUsdcBalance: TokenBalance | null,
+    vaultAssetBalance: TokenBalance | null,
+    vaultUsdcBalance: TokenBalance,
     walletBalance: TokenBalance,
   ): TokenBalance[] {
     const balanceMap = new Map<string, TokenBalance>();
@@ -1924,8 +1942,8 @@ export class ExtendedSVKVesuStateManager {
       });
     };
 
-    put(vaultAssetBalance);
-    if (vaultUsdcBalance) put(vaultUsdcBalance);
+    if (vaultAssetBalance) put(vaultAssetBalance);
+    put(vaultUsdcBalance);
 
     // Merge wallet balances by token address
     const key = walletBalance.token.address.toString();
@@ -2590,7 +2608,14 @@ export class ExtendedSVKVesuStateManager {
   // ── Atomic route builders ────────────────────────────────────────────
 
   private _buildVesuRepayRoutes(totalUsd: number, routes: ExecutionRoute[]): void {
-    const { used, spendsByPool } = this._budget.repayVesuBorrowCapacity(totalUsd);
+    // Repay consumes VA USDC/asset; do not plan more than the budget VA holds after prior
+    // routes (borrow→VA, Vesu→VA, wallet→VA, etc.). Otherwise repayVesuBorrowCapacity would
+    // mutate Vesu debt while spendVaRawUsd could not fund it.
+    const vaCap = this._budget.vaRawUsd;
+    const repayUsd = Math.min(totalUsd, vaCap);
+    if (repayUsd <= CASE_THRESHOLD_USD) return;
+
+    const { used, spendsByPool } = this._budget.repayVesuBorrowCapacity(repayUsd);
     for (const route of spendsByPool) {
       routes.push({ type: RouteType.VESU_REPAY as const, ...route, priority: routes.length });
     }
@@ -2699,7 +2724,7 @@ export class ExtendedSVKVesuStateManager {
   }
 
   private _getVAToEXTENDEDRoute(tryAmount: number, routes: ExecutionRoute[], shouldAddWaitRoute = true): { routes: ExecutionRoute[], remaining: number } {
-    const usable = Math.min(tryAmount, this._budget.vaUsd);
+    const usable = Math.min(tryAmount, this._budget.vaUsdcUsd);
     if (usable > CASE_THRESHOLD_USD) {
       const vaUsed = this._budget.spendVA(usable);
       this._budget.addToExtAvailTrade(vaUsed);
@@ -2719,7 +2744,7 @@ export class ExtendedSVKVesuStateManager {
 
   private _getExtendedToWalletRoute(tryAmount: number, routes: ExecutionRoute[], shouldAddWaitRoute = true): { routes: ExecutionRoute[], remaining: number } {
     if (tryAmount <= CASE_THRESHOLD_USD) return { routes, remaining: tryAmount };
-    const rawCap = this._budget.extAvailWithdraw + this._budget.extAvailUpnl;
+    const rawCap = this._budget.extAvailWithdraw + Math.max(0, this._budget.extAvailUpnl);
     const rawSpend = Math.min(tryAmount, rawCap);
     if (rawSpend <= CASE_THRESHOLD_USD) return { routes, remaining: tryAmount };
     const rawOut = this._budget.spendExtAvailTrade(rawSpend);
@@ -2862,6 +2887,10 @@ export class ExtendedSVKVesuStateManager {
         }
       }
 
+      // todo rereviewe logic on how neg upnl gets handled
+      // esp when equity is below ideal margin, 0 ext withdraw,
+      // and how does closing free capital.
+
       // Step 5b: Equal unwind from both sides
       if (stillNeeded > CASE_THRESHOLD_USD) {
         const combinedFreed = freedPerBtcVesu + freedPerBtcExt;
@@ -2954,7 +2983,9 @@ export class ExtendedSVKVesuStateManager {
    * Design: accumulate all ext-to-wallet moves, add transfer routes at the end (principle #3).
    */
   /**
-   * Unified LTV classifier. Computes both Vesu repay and Extended margin needs,
+   * Unified LTV / exposure classifier: `rebalance()` drives both LTV (debt, margin,
+   * funding) and Vesu↔Extended position alignment. There is no separate imbalance pass.
+   * 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
@@ -3025,6 +3056,7 @@ export class ExtendedSVKVesuStateManager {
       config: {
         positionPrecision: COLLATERAL_PRECISION,
         hfBuffer: 0.05,
+        minRoutableUsd: CASE_THRESHOLD_USD,
       },
     };
   }
@@ -3047,8 +3079,9 @@ export class ExtendedSVKVesuStateManager {
 
   /**
    * 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).
+   * Order: Vesu multiply decrease → Extended decrease → aggregated transfers
+   * (REALISE_PNL, EXTENDED_TO_WALLET + WAIT, WALLET_TO_VA, VESU_BORROW, VESU_REPAY, VA_TO_EXTENDED),
+   * then Vesu multiply increase and Extended increase (need VA / Extended funded first).
    */
   private _buildLtvRoutesFromRebalanceDeltas(d: RebalanceDeltas): ExecutionRoute[] {
     const routes: ExecutionRoute[] = [];
@@ -3062,7 +3095,9 @@ export class ExtendedSVKVesuStateManager {
 
     let multiplyDebtRepayUsd = 0;
 
-    // ── 1) Vesu lever (multiply) first ─────────────────────────────────
+    logger.info(`${this._tag}::_buildLtvRoutesFromRebalanceDeltas d=${JSON.stringify(d)}`);
+
+    // ── 1) Vesu multiply decrease (free collateral / repay) ─────────────
     if (d.dVesuPosition < -btcEps) {
       const xBtc = -d.dVesuPosition;
       // When Vesu sends USD to Extended (dTransferVesuToExt > 0), part of the BTC cut must be the
@@ -3085,12 +3120,29 @@ export class ExtendedSVKVesuStateManager {
       if (d.dVesuDebt < 0) {
         const needRepayUsd = -d.dVesuDebt * debtPrice;
         const multiplyRepayUsd = Math.min(needRepayUsd, swapLegMaxRepayUsd);
+        logger.info(`${this._tag}::_buildLtvRoutesFromRebalanceDeltas ${JSON.stringify({
+          needRepayUsd,
+          multiplyRepayUsd,
+        })}`);
         debtTokenDelta = -(multiplyRepayUsd / debtPrice);
       } else {
         debtTokenDelta = -debtUsdFallback;
       }
+
       const debtAmtW3 = new Web3Number(debtTokenDelta.toFixed(USDC_TOKEN_DECIMALS), USDC_TOKEN_DECIMALS);
       multiplyDebtRepayUsd = Math.abs(debtTokenDelta) * debtPrice;
+      logger.info(`${this._tag}::_buildLtvRoutesFromRebalanceDeltas ${JSON.stringify({
+        debtTokenDelta,
+        debtUsdFallback,
+        swapLegMaxRepayUsd,
+        xBtc,
+        marginBtc,
+        swappedBtc,
+        transferUsdFromVesu,
+        debtPrice,
+        targetLtv,
+        multiplyDebtRepayUsd,
+      })}`);
       routes.push({
         type: RouteType.VESU_MULTIPLY_DECREASE_LEVER,
         poolId: vesuAdapter.config.poolId,
@@ -3111,57 +3163,9 @@ export class ExtendedSVKVesuStateManager {
       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,
-      );
     }
 
-    // ── 2) Extended lever second ──────────────────────────────────────
+    // ── 2) Extended decrease lever only (increase after VA→Ext funding) ─
     if (d.dExtPosition < -btcEps) {
       const amt = new Web3Number(d.dExtPosition.toFixed(COLLATERAL_PRECISION), 8);
       routes.push({
@@ -3171,15 +3175,6 @@ export class ExtendedSVKVesuStateManager {
         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);
     }
 
     // ── 3) Aggregated transfers (no WALLET_TO_EXTENDED; Ext only via VA) ─
@@ -3194,11 +3189,22 @@ export class ExtendedSVKVesuStateManager {
 
     const extToWalletUsd = (negExtAvl < -CASE_THRESHOLD_USD ? Math.abs(negExtAvl) : 0)
       + (negUpnl < -CASE_THRESHOLD_USD ? Math.abs(negUpnl) : 0);
+    logger.info(`${this._tag}::_buildLtvRoutesFromRebalanceDeltas extToWalletUsd=${extToWalletUsd}, negExtAvl=${negExtAvl}, negUpnl=${negUpnl}`);
     if (extToWalletUsd > CASE_THRESHOLD_USD) {
       this._getExtendedToWalletRoute(extToWalletUsd, routes);
       hadExtendedOut = true;
+    } else {
+      // too small to withdraw from extended
+      // reduce any vesu debt
+      // else further repay from va will fail
+      if (d.dVesuDebt < 0) {
+        d.dVesuDebt += (negExtAvl < 0 && negExtAvl > -CASE_THRESHOLD_USD ? Math.abs(negExtAvl) : 0)
+        + (negUpnl < 0 && negUpnl > -CASE_THRESHOLD_USD ? Math.abs(negUpnl) : 0);
+      }
     }
 
+    logger.info(`${this._tag}::_buildLtvRoutesFromRebalanceDeltas d=${JSON.stringify(d)}`);
+
     const walletPull = Math.abs(Math.min(0, d.dWalletUsd));
     const walletToVaUsd = walletPull + extToWalletUsd;
     if (walletToVaUsd > CASE_THRESHOLD_USD) {
@@ -3210,7 +3216,16 @@ export class ExtendedSVKVesuStateManager {
     }
 
     const totalDebtRepayUsd = d.dVesuDebt < 0 ? -d.dVesuDebt * debtPrice : 0;
-    const standaloneRepayUsd = Math.max(0, totalDebtRepayUsd - multiplyDebtRepayUsd);
+    logger.info(`${this._tag}::_buildLtvRoutesFromRebalanceDeltas totalDebtRepayUsd=${totalDebtRepayUsd}`);
+    let standaloneRepayUsd = Math.max(0, totalDebtRepayUsd - multiplyDebtRepayUsd);
+    logger.info(`${this._tag}::_buildLtvRoutesFromRebalanceDeltas standaloneRepayUsd=${standaloneRepayUsd}`);
+    if (standaloneRepayUsd > this._budget.vaRawUsd) {
+      if (Math.abs(standaloneRepayUsd - this._budget.vaRawUsd) < CASE_THRESHOLD_USD) {
+        standaloneRepayUsd = this._budget.vaRawUsd;
+      } else {
+        throw new Error(`${this._tag}::_buildLtvRoutesFromRebalanceDeltas standaloneRepayUsd=${standaloneRepayUsd} > vaRawUsd=${this._budget.vaRawUsd}`);
+      }
+    }
     if (standaloneRepayUsd > CASE_THRESHOLD_USD) {
       this._buildVesuRepayRoutes(standaloneRepayUsd, routes);
     }
@@ -3221,6 +3236,69 @@ export class ExtendedSVKVesuStateManager {
       this._getVAToEXTENDEDRoute(vaToExtUsd, routes, hadExtendedOut);
     }
 
+    // ── Vesu / Extended increase lever: require prior VA funding & VA→Extended where applicable
+    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 marginUsdAmount = externalDepositAmount.toNumber() * (pool.debtPrice ?? 1);
+      const swappedAmount = new Web3Number(
+        ((marginUsdAmount / 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,
+      );
+      this._budget.spendVA(marginUsdAmount);
+    }
+    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);
+    }
+
     return routes;
   }
 
@@ -3428,37 +3506,51 @@ export class ExtendedSVKVesuStateManager {
       dExtUpnl = 0,
       dVaUsd = 0,
       dWalletUsd = 0,
-      dVesuBorrowCapacity = 0;
+      dVesuBorrowCapacity = 0,
+      finalVaUsd = vaUsd,
+      finalExtended = extAvlWithdraw + (Math.max(extUpnl, 0));
 
     // --- Case 1: eco1 needs MORE funds (pull from eco2)
     if (delta > 0) {
       let need = delta;
+      const eps = CASE_THRESHOLD_USD;
 
-      const takeWalletUsd = Math.min(walletUsd, need);
+      const takeWalletUsd = routableDrawAmount(walletUsd, need, eps);
       dWalletUsd -= takeWalletUsd;
       need -= takeWalletUsd;
 
-      const takeVaUsd = Math.min(vaUsd, need);
+      const takeVaUsd = routableDrawAmount(vaUsd, need, eps);
       dVaUsd -= takeVaUsd;
       need -= takeVaUsd;
 
-      const takeVesuBorrowCapacity = Math.min(vesuBorrowCapacity, need);
+      finalVaUsd -= takeVaUsd; // remove, bcz its sent to extended and wont be available for vesu multiply
+      finalVaUsd += walletUsd - takeWalletUsd; // add remaining wallet usd to va
+      // dWallet
+
+      const takeVesuBorrowCapacity = routableDrawAmount(vesuBorrowCapacity, need, eps);
       dVesuBorrowCapacity -= takeVesuBorrowCapacity;
       need -= takeVesuBorrowCapacity;
 
+      finalVaUsd += vesuBorrowCapacity - takeVesuBorrowCapacity; // add remaining vesu borrow capacity to va
+
       // Received into eco1 → distribute proportionally into E1/E2
       const received = delta - need;
       const eco1Sum = extAvlWithdraw + extUpnl;
+      finalExtended += received;
 
       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`);
+        // Negative Extended "liquid" (withdraw + uPnL): cover uPnL deficit first, then avl withdraw.
+        const hole = -eco1Sum;
+        const fillUpnl = Math.min(received, hole);
+        dExtUpnl += fillUpnl;
+        dExtAvlWithdraw += received - fillUpnl;
+        finalExtended -= fillUpnl;
       }
 
-      if (need > 0) {
+      if (need > CASE_THRESHOLD_USD) {
         throw new Error(`${this._tag}: Insufficient funds to cover margin needs`);
       }
     }
@@ -3467,19 +3559,26 @@ export class ExtendedSVKVesuStateManager {
     else if (delta < 0) {
       let need = -delta;
 
-      const takeExtAvlWithdraw = Math.min(extAvlWithdraw, need);
+      const takeExtAvlWithdraw = Math.min(Math.max(extAvlWithdraw, 0), need);
       dExtAvlWithdraw -= takeExtAvlWithdraw;
-      need -= takeExtAvlWithdraw;
 
-      const takeExtUpnl = Math.min(extUpnl, need);
+      const takeExtUpnl = Math.min(Math.max(extUpnl, 0), need);
       dExtUpnl -= takeExtUpnl;
-      need -= takeExtUpnl;
+
+      const netDrawableAmount = takeExtAvlWithdraw + takeExtUpnl;
+      if (netDrawableAmount > CASE_THRESHOLD_USD) {
+        need -= netDrawableAmount;
+        finalExtended -= netDrawableAmount;
+      }
 
       const sent = -delta - need;
 
       // Distribute into eco2 proportionally (optional design choice)
       const eco2Sum = vaUsd + walletUsd + vesuBorrowCapacity;
 
+      const netWalletUsd = walletUsd < CASE_THRESHOLD_USD ? 0 : walletUsd;
+      finalVaUsd += sent + netWalletUsd;
+
       if (eco2Sum >= 0) {
         // all amount is sent to wallet only
         dWalletUsd += sent;
@@ -3488,12 +3587,27 @@ export class ExtendedSVKVesuStateManager {
         throw new Error(`${this._tag}: Unexpected case`);
       }
 
-      if (need > 0) {
+      if (need > CASE_THRESHOLD_USD) {
         throw new Error(`${this._tag}: Insufficient funds to cover margin needs`);
       }
     }
 
-    return { dExtAvlWithdraw, dExtUpnl, dVaUsd, dWalletUsd, dVesuBorrowCapacity, isExtendedToVesu: delta < 0 };
+    return { dExtAvlWithdraw, dExtUpnl, dVaUsd, dWalletUsd, dVesuBorrowCapacity, finalVaUsd, finalExtended, isExtendedToVesu: delta < 0 };
+  }
+
+  private _scaleVesuPoolDeltasByFactor(deltas: VesuPoolDelta[], scale: number): VesuPoolDelta[] {
+    if (scale >= 1 - 1e-15) return deltas;
+    return deltas.map((d) => ({
+      ...d,
+      collateralDelta: new Web3Number(
+        (d.collateralDelta.toNumber() * scale).toFixed(COLLATERAL_PRECISION),
+        d.collateralToken.decimals,
+      ),
+      debtDelta: new Web3Number(
+        (d.debtDelta.toNumber() * scale).toFixed(USDC_TOKEN_DECIMALS),
+        USDC_TOKEN_DECIMALS,
+      ),
+    }));
   }
 
   /**
@@ -3510,6 +3624,11 @@ export class ExtendedSVKVesuStateManager {
    * Computes allocation split between Vesu and Extended, then sources
    * funds and creates lever-increase routes.
    *
+   * Order: {@link _rebalanceFunds} first → project VA / Extended liquid after the same funding
+   * routes (wallet→VA, borrow→VA, VA→Extended, Extended→wallet→VA) → ideal Vesu/Extended deltas
+   * from distributable split → cap common BTC by min(Vesu fundable, Extended fundable) → scale
+   * Vesu deltas and recompute Extended deltas so both sides stay matched.
+   *
    * 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
@@ -3536,19 +3655,10 @@ export class ExtendedSVKVesuStateManager {
     );
     if (distributableAmount.toNumber() <= CASE_THRESHOLD_USD) return [];
 
-    const { vesuAllocationUsd, extendedAllocationUsd } =
-      this._computeAllocationSplit(distributableAmount);
-
-    const vesuDeltas = this._computePerPoolCollateralDeltas(
-      vesuAllocationUsd
-    );
-
-    const extendedPositionDeltas = this._computeExtendedPositionDeltas(vesuDeltas);
-    const vesuDepositAmount = this._computeVesuDepositAmount(vesuDeltas);
     const vesuLeverage = calculateVesuLeverage();
     const extendedLeverage = calculateExtendedLevergae();
 
-    const { dExtAvlWithdraw, dExtUpnl, dVaUsd, dWalletUsd, dVesuBorrowCapacity, isExtendedToVesu } = this._rebalanceFunds({
+    const { dExtAvlWithdraw, dExtUpnl, dVaUsd, dWalletUsd, dVesuBorrowCapacity, isExtendedToVesu, finalVaUsd, finalExtended } = this._rebalanceFunds({
       extAvlWithdraw: this._budget.extAvailWithdraw,
       extUpnl: this._budget.extAvailUpnl,
       vaUsd: this._budget.vaUsd,
@@ -3557,6 +3667,27 @@ export class ExtendedSVKVesuStateManager {
       vesuLeverage,
       extendedLeverage,
     });
+    logger.info(`${this._tag}::_classifyDeposits dExtAvlWithdraw=${dExtAvlWithdraw}, dExtUpnl=${dExtUpnl}, dVaUsd=${dVaUsd}, dWalletUsd=${dWalletUsd}, dVesuBorrowCapacity=${dVesuBorrowCapacity}, isExtendedToVesu=${isExtendedToVesu}, finalVaUsd=${finalVaUsd}`);
+
+    // const { vesuAllocationUsd } = this._computeAllocationSplit(distributableAmount);
+
+    let vesuDeltas = this._computePerPoolCollateralDeltas(new Web3Number(finalVaUsd.toFixed(USDC_TOKEN_DECIMALS), USDC_TOKEN_DECIMALS));
+    const collateralPrice = this._budget.vesuPools[0]?.collateralPrice ?? 0;
+    const collateralDecimals = this._budget.vesuPools[0]?.collateralToken.decimals ?? 0;
+    let _extendedPositionDelta = new Web3Number((finalExtended * extendedLeverage / collateralPrice).toFixed(USDC_TOKEN_DECIMALS), collateralDecimals).toFixedRoundDown(COLLATERAL_PRECISION);
+    logger.info(`${this._tag}::_classifyDeposits extendedPositionDelta=${_extendedPositionDelta}`);
+    logger.info(`${this._tag}::_classifyDeposits vesuDeltas=${JSON.stringify(vesuDeltas)}`);
+    assert(vesuDeltas.length == 1, 'vesuDeltas should have only one delta');
+    const minPositionDelta = Math.min(vesuDeltas[0].collateralDelta.toNumber(), Number(_extendedPositionDelta));
+    logger.info(`${this._tag}::_classifyDeposits minPositionDelta=${minPositionDelta}`);
+    vesuDeltas[0].collateralDelta = new Web3Number(minPositionDelta.toFixed(COLLATERAL_PRECISION), vesuDeltas[0].collateralDelta.decimals);
+    const extendedPositionDeltas: ExtendedPositionDelta[] = [{
+      instrument: this._config.extendedAdapter.config.extendedMarketName ?? 'BTC-USD',
+      delta: new Web3Number((minPositionDelta).toFixed(COLLATERAL_PRECISION), collateralDecimals),
+    }];
+    const vesuDepositAmount = this._computeVesuDepositAmount(vesuDeltas);
+    logger.info(`${this._tag}::_classifyDeposits vesuDepositAmount=${vesuDepositAmount}`);
+
     const routes: ExecutionRoute[] = [];
 
     if (isExtendedToVesu) {
@@ -3595,13 +3726,13 @@ export class ExtendedSVKVesuStateManager {
         !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,
-        });
+        // 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) {
         // removes borrowing capacity after excluding delta capacity that is being briddged out