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

package/dist/index.browser.mjs

@@ -91,6 +91,9 @@ var Web3Number = class _Web3Number2 extends _Web3Number {
     const bn = new _Web3Number2(weiNumber, decimals).dividedBy(10 ** decimals);
     return new _Web3Number2(bn.toString(), decimals);
   }
+  static fromNumber(number, decimals) {
+    return new _Web3Number2(number.toString(), decimals);
+  }
 };
 
 // src/dataTypes/address.ts
@@ -1485,6 +1488,48 @@ _StarknetCallParser.METHOD_BY_SELECTOR = new Map(
 );
 var StarknetCallParser = _StarknetCallParser;
 
+// src/utils/health-factor-math.ts
+var HealthFactorMath = class {
+  static getCollateralRequired(debtAmount, debtPrice, targetHF, maxLTV, collateralPrice, collateralTokenInfo) {
+    const numerator = debtAmount.multipliedBy(debtPrice).multipliedBy(targetHF);
+    const denominator = collateralPrice * maxLTV;
+    const collateralAmount = numerator.dividedBy(denominator);
+    const netCollateral = new Web3Number(collateralAmount.toString(), collateralTokenInfo.decimals);
+    return netCollateral;
+  }
+  static getMinCollateralRequiredOnLooping(debtAmount, debtPrice, targetHF, maxLTV, collateralPrice, collateralTokenInfo) {
+    const netCollateral = this.getCollateralRequired(debtAmount, debtPrice, targetHF, maxLTV, collateralPrice, collateralTokenInfo);
+    const collateralFromDebt = new Web3Number(debtAmount.multipliedBy(debtPrice).dividedBy(collateralPrice).toString(), collateralTokenInfo.decimals);
+    return netCollateral.minus(collateralFromDebt);
+  }
+  static getHealthFactor(collateralAmount, collateralPrice, maxLTV, debtAmount, debtPrice) {
+    const numerator = collateralAmount.multipliedBy(collateralPrice).multipliedBy(maxLTV);
+    const denominator = debtAmount.multipliedBy(debtPrice);
+    const healthFactor = numerator.dividedBy(denominator);
+    return healthFactor.toNumber();
+  }
+  static getMaxDebtAmountOnLooping(collateralAmount, collateralPrice, maxLTV, targetHF, debtPrice, debtTokenInfo) {
+    const numerator = collateralAmount.multipliedBy(collateralPrice).multipliedBy(maxLTV);
+    logger.verbose(`HealthFactorMath: Max debt amount on looping numerator: ${numerator.toNumber()}, collateralAmount: ${collateralAmount.toNumber()}, collateralPrice: ${collateralPrice}, maxLTV: ${maxLTV}, targetHF: ${targetHF}, debtPrice: ${debtPrice}`);
+    const denominator = targetHF - maxLTV;
+    logger.verbose(`HealthFactorMath: Max debt amount on looping denominator: ${denominator}`);
+    const debtAmountUSD = numerator.dividedBy(denominator);
+    logger.verbose(`HealthFactorMath: Max debt amount on looping debtAmountUSD: ${debtAmountUSD.toNumber()}`);
+    const debtAmount = debtAmountUSD.dividedBy(debtPrice);
+    logger.verbose(`HealthFactorMath: Max debt amount on looping debtAmount: ${debtAmount.toNumber()}`);
+    return new Web3Number(debtAmount.toString(), debtTokenInfo.decimals);
+  }
+  static getMaxDebtAmount(collateralAmount, collateralPrice, maxLTV, targetHF, debtPrice, debtTokenInfo) {
+    const numerator = collateralAmount.multipliedBy(collateralPrice).multipliedBy(maxLTV);
+    logger.verbose(`HealthFactorMath: Max debt amount numerator: ${numerator.toNumber()}, collateralAmount: ${collateralAmount.toNumber()}, collateralPrice: ${collateralPrice}, maxLTV: ${maxLTV}, targetHF: ${targetHF}, debtPrice: ${debtPrice}`);
+    const denominator = targetHF * debtPrice;
+    logger.verbose(`HealthFactorMath: Max debt amount denominator: ${denominator}, targetHF: ${targetHF}, debtPrice: ${debtPrice}`);
+    const debtAmount = numerator.dividedBy(denominator);
+    logger.verbose(`HealthFactorMath: Max debt amount: ${debtAmount.toNumber()}, numerator: ${numerator.toNumber()}, denominator: ${denominator}`);
+    return new Web3Number(debtAmount.toString(), debtTokenInfo.decimals);
+  }
+};
+
 // src/utils/index.ts
 function assert(condition, message) {
   if (!condition) {
@@ -6477,6 +6522,10 @@ var VaultProtocol = {
   name: "Vault",
   logo: ""
 };
+var TrovesProtocol = {
+  name: "Troves",
+  logo: "https://app.troves.fi/favicon.ico"
+};
 var Protocols = {
   NONE: NoneProtocol,
   VESU: VesuProtocol,
@@ -6484,7 +6533,8 @@ var Protocols = {
   EXTENDED: ExtendedProtocol,
   EKUBO: EkuboProtocol,
   AVNU: AvnuProtocol,
-  VAULT: VaultProtocol
+  VAULT: VaultProtocol,
+  TROVES: TrovesProtocol
 };
 
 // src/interfaces/initializable.ts
@@ -34219,48 +34269,6 @@ var AbisConfig = {
   }
 };
 
-// src/utils/health-factor-math.ts
-var HealthFactorMath = class {
-  static getCollateralRequired(debtAmount, debtPrice, targetHF, maxLTV, collateralPrice, collateralTokenInfo) {
-    const numerator = debtAmount.multipliedBy(debtPrice).multipliedBy(targetHF);
-    const denominator = collateralPrice * maxLTV;
-    const collateralAmount = numerator.dividedBy(denominator);
-    const netCollateral = new Web3Number(collateralAmount.toString(), collateralTokenInfo.decimals);
-    return netCollateral;
-  }
-  static getMinCollateralRequiredOnLooping(debtAmount, debtPrice, targetHF, maxLTV, collateralPrice, collateralTokenInfo) {
-    const netCollateral = this.getCollateralRequired(debtAmount, debtPrice, targetHF, maxLTV, collateralPrice, collateralTokenInfo);
-    const collateralFromDebt = new Web3Number(debtAmount.multipliedBy(debtPrice).dividedBy(collateralPrice).toString(), collateralTokenInfo.decimals);
-    return netCollateral.minus(collateralFromDebt);
-  }
-  static getHealthFactor(collateralAmount, collateralPrice, maxLTV, debtAmount, debtPrice) {
-    const numerator = collateralAmount.multipliedBy(collateralPrice).multipliedBy(maxLTV);
-    const denominator = debtAmount.multipliedBy(debtPrice);
-    const healthFactor = numerator.dividedBy(denominator);
-    return healthFactor.toNumber();
-  }
-  static getMaxDebtAmountOnLooping(collateralAmount, collateralPrice, maxLTV, targetHF, debtPrice, debtTokenInfo) {
-    const numerator = collateralAmount.multipliedBy(collateralPrice).multipliedBy(maxLTV);
-    logger.verbose(`HealthFactorMath: Max debt amount on looping numerator: ${numerator.toNumber()}, collateralAmount: ${collateralAmount.toNumber()}, collateralPrice: ${collateralPrice}, maxLTV: ${maxLTV}, targetHF: ${targetHF}, debtPrice: ${debtPrice}`);
-    const denominator = targetHF - maxLTV;
-    logger.verbose(`HealthFactorMath: Max debt amount on looping denominator: ${denominator}`);
-    const debtAmountUSD = numerator.dividedBy(denominator);
-    logger.verbose(`HealthFactorMath: Max debt amount on looping debtAmountUSD: ${debtAmountUSD.toNumber()}`);
-    const debtAmount = debtAmountUSD.dividedBy(debtPrice);
-    logger.verbose(`HealthFactorMath: Max debt amount on looping debtAmount: ${debtAmount.toNumber()}`);
-    return new Web3Number(debtAmount.toString(), debtTokenInfo.decimals);
-  }
-  static getMaxDebtAmount(collateralAmount, collateralPrice, maxLTV, targetHF, debtPrice, debtTokenInfo) {
-    const numerator = collateralAmount.multipliedBy(collateralPrice).multipliedBy(maxLTV);
-    logger.verbose(`HealthFactorMath: Max debt amount numerator: ${numerator.toNumber()}, collateralAmount: ${collateralAmount.toNumber()}, collateralPrice: ${collateralPrice}, maxLTV: ${maxLTV}, targetHF: ${targetHF}, debtPrice: ${debtPrice}`);
-    const denominator = targetHF * debtPrice;
-    logger.verbose(`HealthFactorMath: Max debt amount denominator: ${denominator}, targetHF: ${targetHF}, debtPrice: ${debtPrice}`);
-    const debtAmount = numerator.dividedBy(denominator);
-    logger.verbose(`HealthFactorMath: Max debt amount: ${debtAmount.toNumber()}, numerator: ${numerator.toNumber()}, denominator: ${denominator}`);
-    return new Web3Number(debtAmount.toString(), debtTokenInfo.decimals);
-  }
-};
-
 // src/strategies/vesu-extended-strategy/utils/helper.ts
 var returnFormattedAmount = (amount, toTokenDecimals) => {
   const formattedAmount = "0x" + BigInt(Math.floor(amount * 10 ** toTokenDecimals)).toString(16);
@@ -34903,6 +34911,7 @@ var VesuMultiplyAdapter = class _VesuMultiplyAdapter extends BaseAdapter {
     const collateralToken = this.config.collateral;
     const debtToken = this.config.debt;
     const { contract: multiplyContract } = this._getMultiplyContract();
+    this.lastSwapPriceInfo = null;
     const {
       existingCollateralInfo,
       existingDebtInfo,
@@ -34939,9 +34948,15 @@ var VesuMultiplyAdapter = class _VesuMultiplyAdapter extends BaseAdapter {
     let marginSwapLimitAmount = Web3Number.fromWei(0, collateralToken.decimals);
     let addedCollateral = params.amount;
     let approveAmount = params.amount;
+    let aggregatedFromAmount = 0;
+    let aggregatedToAmount = 0;
+    let aggregatedFromSymbol = debtToken.symbol;
+    const aggregatedToSymbol = collateralToken.symbol;
+    let executedSwapCount = 0;
     if (params.marginSwap) {
       const marginToken = params.marginSwap.marginToken;
       const requiredAmount = params.amount;
+      assert(marginToken.address.eq(debtToken.address), "Margin token must be the same as debt token");
       const marginSwapQuote = await ekuboQuoter.getQuoteExactOutput(
         marginToken.address.address,
         collateralToken.address.address,
@@ -34957,6 +34972,11 @@ var VesuMultiplyAdapter = class _VesuMultiplyAdapter extends BaseAdapter {
         marginToken,
         collateralToken
       );
+      const marginSwapInputAmount = Web3Number.fromWei(marginSwapQuote.total_calculated, marginToken.decimals).abs().toNumber();
+      const marginSwapOutputAmount = requiredAmount.abs().toNumber();
+      aggregatedFromAmount += marginSwapInputAmount;
+      aggregatedToAmount += marginSwapOutputAmount;
+      executedSwapCount += 1;
       approveAmount = Web3Number.fromWei(marginSwapQuote.total_calculated, marginToken.decimals).multipliedBy(1 + this.maxSlippage).abs();
     }
     let debtAmount = this._computeTargetDebtDelta(
@@ -34980,10 +35000,6 @@ var VesuMultiplyAdapter = class _VesuMultiplyAdapter extends BaseAdapter {
     if (!debtAmount.isZero() && debtAmount.greaterThan(0)) {
       try {
         let swapQuote;
-        const debtAmountInCollateralUnits = new Web3Number(
-          debtAmount.multipliedBy(debtPrice).dividedBy(collateralPrice).toFixed(6),
-          collateralToken.decimals
-        );
         if (params.leverSwap?.exactOutput) {
           swapQuote = await ekuboQuoter.getQuoteExactOutput(
             debtToken.address.address,
@@ -35007,17 +35023,9 @@ var VesuMultiplyAdapter = class _VesuMultiplyAdapter extends BaseAdapter {
           ).abs().toNumber();
           const inputAmt = debtAmount.abs().toNumber();
           const outputAmt = quoteOutputAmount;
-          this.lastSwapPriceInfo = {
-            source: "ekubo",
-            fromTokenSymbol: debtToken.symbol,
-            toTokenSymbol: collateralToken.symbol,
-            fromAmount: inputAmt,
-            toAmount: outputAmt,
-            effectivePrice: outputAmt !== 0 ? inputAmt / outputAmt : 0
-          };
-          logger.verbose(
-            `${_VesuMultiplyAdapter.name}::_getIncreaseCalldata stored price info: ${inputAmt} ${debtToken.symbol} \u2192 ${outputAmt} ${collateralToken.symbol}, effectivePrice=${this.lastSwapPriceInfo.effectivePrice}`
-          );
+          aggregatedFromAmount += inputAmt;
+          aggregatedToAmount += outputAmt;
+          executedSwapCount += 1;
           leverSwap = ekuboQuoter.getVesuMultiplyQuote(
             swapQuote,
             debtToken,
@@ -35035,6 +35043,19 @@ var VesuMultiplyAdapter = class _VesuMultiplyAdapter extends BaseAdapter {
         );
       }
     }
+    if (executedSwapCount > 0) {
+      this.lastSwapPriceInfo = {
+        source: "ekubo",
+        fromTokenSymbol: aggregatedFromSymbol ?? debtToken.symbol,
+        toTokenSymbol: aggregatedToSymbol,
+        fromAmount: aggregatedFromAmount,
+        toAmount: aggregatedToAmount,
+        effectivePrice: aggregatedToAmount !== 0 ? aggregatedFromAmount / aggregatedToAmount : 0
+      };
+      logger.verbose(
+        `${_VesuMultiplyAdapter.name}::_getIncreaseCalldata stored aggregated price info: ${aggregatedFromAmount} ${this.lastSwapPriceInfo.fromTokenSymbol} \u2192 ${aggregatedToAmount} ${aggregatedToSymbol}, effectivePrice=${this.lastSwapPriceInfo.effectivePrice}, swaps=${executedSwapCount}`
+      );
+    }
     logger.verbose(
       `${_VesuMultiplyAdapter.name}::_getIncreaseCalldata leverSwapLimitAmount: ${leverSwapLimitAmount.toWei()}`
     );
@@ -35067,10 +35088,21 @@ var VesuMultiplyAdapter = class _VesuMultiplyAdapter extends BaseAdapter {
       approveAmount
     };
   }
+  // private _setLastSwapPriceAsNoSwap(): void {
+  //   this.lastSwapPriceInfo = {
+  //     source: "no-swap",
+  //     fromTokenSymbol: this.config.collateral.symbol,
+  //     toTokenSymbol: this.config.debt.symbol,
+  //     fromAmount: 0,
+  //     toAmount: 0,
+  //     effectivePrice: 0,
+  //   };
+  // }
   async _buildDecreaseLikeCalldata(params) {
     const collateralToken = this.config.collateral;
     const debtToken = this.config.debt;
     const { contract: multiplyContract } = this._getMultiplyContract();
+    this.lastSwapPriceInfo = null;
     const ekuboQuoter = new EkuboQuoter(
       this.config.networkConfig,
       this.config.pricer
@@ -35079,6 +35111,9 @@ var VesuMultiplyAdapter = class _VesuMultiplyAdapter extends BaseAdapter {
     let leverSwapWeights = [];
     let leverSwapLimitAmount = Web3Number.fromWei(0, collateralToken.decimals);
     let leverCollateralUsed = Web3Number.fromWei(0, collateralToken.decimals);
+    let aggregatedFromAmount = 0;
+    let aggregatedToAmount = 0;
+    let executedSwapCount = 0;
     if (params.closePosition) {
       const debtQuote = await ekuboQuoter.getQuoteExactOutput(
         collateralToken.address.address,
@@ -35097,6 +35132,9 @@ var VesuMultiplyAdapter = class _VesuMultiplyAdapter extends BaseAdapter {
         collateralToken.decimals
       ).abs();
       leverSwapLimitAmount = leverCollateralUsed.multipliedBy(1 + this.maxSlippage);
+      aggregatedFromAmount += leverCollateralUsed.toNumber();
+      aggregatedToAmount += params.debtToRepayAbs.abs().toNumber();
+      executedSwapCount += 1;
     } else {
       if (params.collateralPrice === void 0 || params.debtPrice === void 0) {
         throw new Error(
@@ -35118,17 +35156,9 @@ var VesuMultiplyAdapter = class _VesuMultiplyAdapter extends BaseAdapter {
           leverSwapQuote.total_calculated,
           debtToken.decimals
         ).abs().toNumber();
-        this.lastSwapPriceInfo = {
-          source: "ekubo",
-          fromTokenSymbol: collateralToken.symbol,
-          toTokenSymbol: debtToken.symbol,
-          fromAmount: inputAmt,
-          toAmount: outputAmt,
-          effectivePrice: outputAmt !== 0 ? outputAmt / inputAmt : 0
-        };
-        logger.verbose(
-          `${_VesuMultiplyAdapter.name}::_buildDecreaseLikeCalldata stored price info: ${inputAmt} ${collateralToken.symbol} \u2192 ${outputAmt} ${debtToken.symbol}, effectivePrice=${this.lastSwapPriceInfo.effectivePrice}`
-        );
+        aggregatedFromAmount += inputAmt;
+        aggregatedToAmount += outputAmt;
+        executedSwapCount += 1;
         leverSwap = ekuboQuoter.getVesuMultiplyQuote(
           leverSwapQuote,
           collateralToken,
@@ -35151,6 +35181,7 @@ var VesuMultiplyAdapter = class _VesuMultiplyAdapter extends BaseAdapter {
     );
     const withdrawSwapWeights = [];
     if (params.outputToken && !params.outputToken.address.eq(collateralToken.address)) {
+      assert(params.outputToken.address.eq(debtToken.address), "Withdraw output token must be the same as debt token");
       const residualCollateral = params.closePosition ? params.existingCollateral.minus(leverCollateralUsed) : params.subMargin;
       const outputTokenPrice = await this.config.pricer.getPrice(params.outputToken.symbol);
       if (residualCollateral.greaterThan(0)) {
@@ -35167,12 +35198,34 @@ var VesuMultiplyAdapter = class _VesuMultiplyAdapter extends BaseAdapter {
           );
           withdrawSwap = built.swaps;
           withdrawSwapWeights.push(...built.weights);
+          const withdrawOutputAmount = Web3Number.fromWei(
+            withdrawQuote.total_calculated,
+            params.outputToken.decimals
+          ).abs().toNumber();
+          aggregatedFromAmount += residualCollateral.toNumber();
+          aggregatedToAmount += withdrawOutputAmount;
+          executedSwapCount += 1;
           const estimatedOutput = residualCollateral.multipliedBy(params.collateralPrice).dividedBy(outputTokenPrice.price);
           estimatedOutput.decimals = params.outputToken.decimals;
           withdrawSwapLimitAmount = estimatedOutput.multipliedBy(1 - this.maxSlippage);
         }
       }
     }
+    if (executedSwapCount > 0) {
+      this.lastSwapPriceInfo = {
+        source: "ekubo",
+        fromTokenSymbol: collateralToken.symbol,
+        toTokenSymbol: debtToken.symbol,
+        fromAmount: aggregatedFromAmount,
+        toAmount: aggregatedToAmount,
+        effectivePrice: aggregatedFromAmount !== 0 ? aggregatedToAmount / aggregatedFromAmount : 0
+      };
+      logger.verbose(
+        `${_VesuMultiplyAdapter.name}::_buildDecreaseLikeCalldata stored aggregated price info: ${aggregatedFromAmount} ${collateralToken.symbol} \u2192 ${aggregatedToAmount} ${debtToken.symbol}, effectivePrice=${this.lastSwapPriceInfo.effectivePrice}, swaps=${executedSwapCount}`
+      );
+    } else {
+      this.lastSwapPriceInfo = null;
+    }
     logger.debug(
       `${_VesuMultiplyAdapter.name}::_buildDecreaseLikeCalldata leverSwapCount=${leverSwap.length}, withdrawSwapCount=${withdrawSwap.length}, withdrawSwapLimitAmount=${withdrawSwapLimitAmount.toNumber()}, subMargin=${params.subMargin.toNumber()}`
     );
@@ -35981,13 +36034,13 @@ var ExtendedAdapter = class _ExtendedAdapter extends BaseAdapter {
     this.minimumExtendedMovementAmount = this.config.minimumExtendedMovementAmount ?? 5;
     this.client = client;
     this.retryDelayForOrderStatus = this.config.retryDelayForOrderStatus ?? 3e3;
-    this.usdceToken = this.config.supportedPositions[0].asset;
+    this.usdcToken = this.config.supportedPositions[0].asset;
   }
   _depositApproveProofReadableId() {
-    return `extended_approve_${this.usdceToken.symbol}`;
+    return `extended_approve_${this.usdcToken.symbol}`;
   }
   _depositCallProofReadableId() {
-    return `extended_deposit_${this.usdceToken.symbol}`;
+    return `extended_deposit_${this.usdcToken.symbol}`;
   }
   //abstract means the method has no implementation in this class; instead, child classes must implement it.
   async getAPY(supportedPosition) {
@@ -36056,7 +36109,7 @@ var ExtendedAdapter = class _ExtendedAdapter extends BaseAdapter {
   _getDepositLeaf() {
     return [
       {
-        target: this.usdceToken.address,
+        target: this.usdcToken.address,
         method: "approve",
         packedArguments: [this.config.extendedContract.toBigInt()],
         id: this._depositApproveProofReadableId(),
@@ -36076,14 +36129,14 @@ var ExtendedAdapter = class _ExtendedAdapter extends BaseAdapter {
   }
   async getDepositCall(params) {
     try {
-      const salt = Math.floor(Math.random() * 10 ** this.usdceToken.decimals);
+      const salt = Math.floor(Math.random() * 10 ** this.usdcToken.decimals);
       const amount = uint25616.bnToUint256(params.amount.toWei());
       return [
         {
           proofReadableId: this._depositApproveProofReadableId(),
           sanitizer: SIMPLE_SANITIZER,
           call: {
-            contractAddress: this.usdceToken.address,
+            contractAddress: this.usdcToken.address,
             selector: hash8.getSelectorFromName("approve"),
             calldata: [
               this.config.extendedContract.toBigInt(),
@@ -36984,8 +37037,8 @@ var AvnuAdapter = class _AvnuAdapter extends BaseAdapter {
   }
 };
 
-// src/strategies/universal-strategy.tsx
-import { CallData, Contract as Contract14, num as num12, uint256 as uint25619 } from "starknet";
+// src/strategies/universal-adapters/svk-troves-adapter.ts
+import { hash as hash11, uint256 as uint25619, Contract as Contract14 } from "starknet";
 
 // src/data/universal-vault.abi.json
 var universal_vault_abi_default = [
@@ -38669,6 +38722,272 @@ var universal_vault_abi_default = [
   }
 ];
 
+// src/strategies/universal-adapters/svk-troves-adapter.ts
+var DEFAULT_TROVES_STRATEGIES_API = "https://app.troves.fi/api/strategies";
+function parseTrovesApyField(raw) {
+  if (typeof raw === "number" && Number.isFinite(raw)) {
+    return raw;
+  }
+  if (typeof raw === "string") {
+    const n = Number.parseFloat(raw);
+    if (Number.isFinite(n)) {
+      return n;
+    }
+  }
+  return 0;
+}
+var SvkTrovesAdapter = class _SvkTrovesAdapter extends BaseAdapter {
+  constructor(config) {
+    super(config, _SvkTrovesAdapter.name, Protocols.TROVES);
+    this.config = config;
+  }
+  /** Owner used for share balance + `due_assets_from_owner`. */
+  _positionOwner() {
+    return this.config.positionOwner ?? this.config.vaultAllocator;
+  }
+  /**
+   * Proof readable IDs must stay ≤ 31 chars (Cairo short string). We derive a short ASCII suffix from
+   * `strategyVault` address so multiple SVK adapters in one tree stay distinct.
+   */
+  _proofSuffix() {
+    return this.config.strategyVault.address.replace(/^0x/, "").slice(-6);
+  }
+  _depositApproveProofReadableId() {
+    return `appr_dep_svk_${this._proofSuffix()}`;
+  }
+  _depositCallProofReadableId() {
+    return `dep_svk_${this._proofSuffix()}`;
+  }
+  _withdrawCallProofReadableId() {
+    return `wtdrw_svk_${this._proofSuffix()}`;
+  }
+  async getAPY(supportedPosition) {
+    const CACHE_KEY = `svk_apy_${this.config.trovesStrategyId}`;
+    const cached = this.getCache(CACHE_KEY);
+    if (cached) {
+      return cached;
+    }
+    const url = this.config.trovesStrategiesApiUrl ?? DEFAULT_TROVES_STRATEGIES_API;
+    try {
+      const res = await fetch(url);
+      if (!res.ok) {
+        logger.warn(`${_SvkTrovesAdapter.name}::getAPY: HTTP ${res.status} from ${url}`);
+        const fallback = { apy: 0, type: "base" /* BASE */ };
+        this.setCache(CACHE_KEY, fallback, 3e5);
+        return fallback;
+      }
+      const body = await res.json();
+      const row = body.strategies?.find((s) => s.id === this.config.trovesStrategyId);
+      if (!row) {
+        logger.warn(
+          `${_SvkTrovesAdapter.name}::getAPY: strategy id not found: ${this.config.trovesStrategyId}`
+        );
+        const fallback = { apy: 0, type: "base" /* BASE */ };
+        this.setCache(CACHE_KEY, fallback, 3e5);
+        return fallback;
+      }
+      const apy = parseTrovesApyField(row.apy);
+      const result = { apy, type: "base" /* BASE */ };
+      this.setCache(CACHE_KEY, result, 3e5);
+      return result;
+    } catch (error) {
+      logger.error(`${_SvkTrovesAdapter.name}::getAPY:`, error);
+      throw error;
+    }
+  }
+  async getPosition(supportedPosition) {
+    const CACHE_KEY = `svk_pos_${this.config.strategyVault.address}_${this._positionOwner().address}`;
+    const cached = this.getCache(CACHE_KEY);
+    if (cached) {
+      return cached;
+    }
+    try {
+      const vault = new Contract14({
+        abi: universal_vault_abi_default,
+        address: this.config.strategyVault.address,
+        providerOrAccount: this.config.networkConfig.provider
+      });
+      const owner = this._positionOwner();
+      const decimals = supportedPosition.asset.decimals;
+      const shares = await vault.balance_of(owner.address);
+      const shareU256 = uint25619.bnToUint256(shares);
+      const liquidAssetsRaw = await vault.convert_to_assets(shareU256);
+      const liquid = Web3Number.fromWei(liquidAssetsRaw.toString(), decimals);
+      let pending = Web3Number.fromWei("0", decimals);
+      try {
+        const dueRaw = await vault.call("due_assets_from_owner", [owner.address]);
+        pending = Web3Number.fromWei(dueRaw.toString(), decimals);
+      } catch (e) {
+        logger.warn(
+          `${_SvkTrovesAdapter.name}::getPosition: due_assets_from_owner failed (treating as 0): ${e.message}`
+        );
+      }
+      const total = liquid.plus(pending);
+      const remarks = `Troves ${this.config.trovesStrategyId} holdings`;
+      const result = {
+        amount: total,
+        remarks
+      };
+      this.setCache(CACHE_KEY, result, 6e4);
+      return result;
+    } catch (error) {
+      logger.error(`${_SvkTrovesAdapter.name}::getPosition:`, error);
+      throw error;
+    }
+  }
+  async maxDeposit(amount) {
+    const baseToken = this.config.baseToken;
+    if (!amount) {
+      return {
+        tokenInfo: baseToken,
+        amount: new Web3Number("999999999999999999999999999", baseToken.decimals),
+        usdValue: 1e27,
+        remarks: "Max deposit (unbounded placeholder)",
+        apy: await this.getAPY({ asset: baseToken, isDebt: false }),
+        protocol: this.protocol
+      };
+    }
+    const usdValue = await this.getUSDValue(baseToken, amount);
+    return {
+      tokenInfo: baseToken,
+      amount,
+      usdValue,
+      remarks: "Deposit amount",
+      apy: await this.getAPY({ asset: baseToken, isDebt: false }),
+      protocol: this.protocol
+    };
+  }
+  async maxWithdraw() {
+    const baseToken = this.config.baseToken;
+    const current = await this.getPosition({ asset: baseToken, isDebt: false });
+    const pos = current ?? { amount: new Web3Number("0", baseToken.decimals), remarks: "" };
+    const usdValue = await this.getUSDValue(baseToken, pos.amount);
+    return {
+      tokenInfo: baseToken,
+      amount: pos.amount,
+      usdValue,
+      remarks: "Max withdraw (liquid + pending redemption, underlying units)",
+      apy: await this.getAPY({ asset: baseToken, isDebt: false }),
+      protocol: this.protocol
+    };
+  }
+  _getDepositLeaf() {
+    const baseToken = this.config.baseToken;
+    const strategyVault = this.config.strategyVault;
+    const receiver = this.config.vaultAllocator;
+    return [
+      {
+        target: baseToken.address,
+        method: "approve",
+        packedArguments: [strategyVault.toBigInt()],
+        sanitizer: SIMPLE_SANITIZER,
+        id: this._depositApproveProofReadableId()
+      },
+      {
+        target: strategyVault,
+        method: "deposit",
+        packedArguments: [receiver.toBigInt()],
+        sanitizer: SIMPLE_SANITIZER,
+        id: this._depositCallProofReadableId()
+      }
+    ];
+  }
+  _getWithdrawLeaf() {
+    const strategyVault = this.config.strategyVault;
+    const recv = this.config.vaultAllocator;
+    const owner = this.config.vaultAllocator;
+    return [
+      {
+        target: strategyVault,
+        method: "withdraw",
+        packedArguments: [recv.toBigInt(), owner.toBigInt()],
+        sanitizer: SIMPLE_SANITIZER,
+        id: this._withdrawCallProofReadableId()
+      }
+    ];
+  }
+  getDepositAdapter() {
+    const leafConfigs = this._getDepositLeaf();
+    const leaves = leafConfigs.map((config) => {
+      const { target, method, packedArguments, sanitizer, id } = config;
+      return this.constructSimpleLeafData({ id, target, method, packedArguments }, sanitizer);
+    });
+    return { leaves, callConstructor: this.getDepositCall.bind(this) };
+  }
+  getWithdrawAdapter() {
+    const leafConfigs = this._getWithdrawLeaf();
+    const leaves = leafConfigs.map((config) => {
+      const { target, method, packedArguments, sanitizer, id } = config;
+      return this.constructSimpleLeafData({ id, target, method, packedArguments }, sanitizer);
+    });
+    return { leaves, callConstructor: this.getWithdrawCall.bind(this) };
+  }
+  async getDepositCall(params) {
+    const baseToken = this.config.baseToken;
+    const strategyVault = this.config.strategyVault;
+    const amount = params.amount;
+    const uint256Amount = uint25619.bnToUint256(amount.toWei());
+    const receiver = this.config.vaultAllocator;
+    return [
+      {
+        proofReadableId: this._depositApproveProofReadableId(),
+        sanitizer: SIMPLE_SANITIZER,
+        call: {
+          contractAddress: baseToken.address,
+          selector: hash11.getSelectorFromName("approve"),
+          calldata: [
+            strategyVault.toBigInt(),
+            toBigInt(uint256Amount.low.toString()),
+            toBigInt(uint256Amount.high.toString())
+          ]
+        }
+      },
+      {
+        proofReadableId: this._depositCallProofReadableId(),
+        sanitizer: SIMPLE_SANITIZER,
+        call: {
+          contractAddress: strategyVault,
+          selector: hash11.getSelectorFromName("deposit"),
+          calldata: [
+            toBigInt(uint256Amount.low.toString()),
+            toBigInt(uint256Amount.high.toString()),
+            receiver.toBigInt()
+          ]
+        }
+      }
+    ];
+  }
+  async getWithdrawCall(params) {
+    const strategyVault = this.config.strategyVault;
+    const amount = params.amount;
+    const uint256Amount = uint25619.bnToUint256(amount.toWei());
+    const recv = this.config.vaultAllocator;
+    const owner = this.config.vaultAllocator;
+    return [
+      {
+        proofReadableId: this._withdrawCallProofReadableId(),
+        sanitizer: SIMPLE_SANITIZER,
+        call: {
+          contractAddress: strategyVault,
+          selector: hash11.getSelectorFromName("withdraw"),
+          calldata: [
+            toBigInt(uint256Amount.low.toString()),
+            toBigInt(uint256Amount.high.toString()),
+            recv.toBigInt(),
+            owner.toBigInt()
+          ]
+        }
+      }
+    ];
+  }
+  getHealthFactor() {
+    return Promise.resolve(10);
+  }
+};
+
+// src/strategies/universal-strategy.tsx
+import { CallData, Contract as Contract15, num as num12, uint256 as uint25620 } from "starknet";
+
 // src/data/vault-manager.abi.json
 var vault_manager_abi_default = [
   {
@@ -39334,12 +39653,12 @@ var UniversalStrategy = class _UniversalStrategy extends BaseStrategy {
     );
     this.metadata = metadata;
     this.address = metadata.address;
-    this.contract = new Contract14({
+    this.contract = new Contract15({
       abi: universal_vault_abi_default,
       address: this.address.address,
       providerOrAccount: this.config.provider
     });
-    this.managerContract = new Contract14({
+    this.managerContract = new Contract15({
       abi: vault_manager_abi_default,
       address: this.metadata.additionalInfo.manager.address,
       providerOrAccount: this.config.provider
@@ -39393,17 +39712,17 @@ var UniversalStrategy = class _UniversalStrategy extends BaseStrategy {
       amountInfo.tokenInfo.address.eq(this.asset().address),
       "Deposit token mismatch"
     );
-    const assetContract = new Contract14({
+    const assetContract = new Contract15({
       abi: universal_vault_abi_default,
       address: this.asset().address.address,
       providerOrAccount: this.config.provider
     });
     const call1 = assetContract.populate("approve", [
       this.address.address,
-      uint25619.bnToUint256(amountInfo.amount.toWei())
+      uint25620.bnToUint256(amountInfo.amount.toWei())
     ]);
     const call2 = this.contract.populate("deposit", [
-      uint25619.bnToUint256(amountInfo.amount.toWei()),
+      uint25620.bnToUint256(amountInfo.amount.toWei()),
       receiver.address
     ]);
     return [call1, call2];
@@ -39413,9 +39732,9 @@ var UniversalStrategy = class _UniversalStrategy extends BaseStrategy {
       amountInfo.tokenInfo.address.eq(this.asset().address),
       "Withdraw token mismatch"
     );
-    const shares = await this.contract.call("convert_to_shares", [uint25619.bnToUint256(amountInfo.amount.toWei())]);
+    const shares = await this.contract.call("convert_to_shares", [uint25620.bnToUint256(amountInfo.amount.toWei())]);
     const call = this.contract.populate("request_redeem", [
-      uint25619.bnToUint256(shares.toString()),
+      uint25620.bnToUint256(shares.toString()),
       receiver.address,
       owner.address
     ]);
@@ -39425,7 +39744,7 @@ var UniversalStrategy = class _UniversalStrategy extends BaseStrategy {
     const shares = await this.contract.call("balanceOf", [user.address], { blockIdentifier });
     const assets = await this.contract.call(
       "convert_to_assets",
-      [uint25619.bnToUint256(shares)],
+      [uint25620.bnToUint256(shares)],
       { blockIdentifier }
     );
     const amount = Web3Number.fromWei(
@@ -40359,19 +40678,19 @@ var UniversalStrategies = [
 ];
 
 // src/strategies/svk-strategy.ts
-import { Contract as Contract15, num as num13, uint256 as uint25620 } from "starknet";
+import { Contract as Contract16, num as num13, uint256 as uint25621 } from "starknet";
 var SVKStrategy = class extends BaseStrategy {
   constructor(config, pricer, metadata) {
     super(config);
     this.pricer = pricer;
     this.metadata = metadata;
     this.address = metadata.address;
-    this.contract = new Contract15({
+    this.contract = new Contract16({
       abi: universal_vault_abi_default,
       address: this.address.address,
       providerOrAccount: this.config.provider
     });
-    this.managerContract = new Contract15({
+    this.managerContract = new Contract16({
       abi: vault_manager_abi_default,
       address: this.metadata.additionalInfo.manager.address,
       providerOrAccount: this.config.provider
@@ -40388,17 +40707,17 @@ var SVKStrategy = class extends BaseStrategy {
       amountInfo.tokenInfo.address.eq(this.asset().address),
       "Deposit token mismatch"
     );
-    const assetContract = new Contract15({
+    const assetContract = new Contract16({
       abi: universal_vault_abi_default,
       address: this.asset().address.address,
       providerOrAccount: this.config.provider
     });
     const call1 = assetContract.populate("approve", [
       this.address.address,
-      uint25620.bnToUint256(amountInfo.amount.toWei())
+      uint25621.bnToUint256(amountInfo.amount.toWei())
     ]);
     const call2 = this.contract.populate("deposit", [
-      uint25620.bnToUint256(amountInfo.amount.toWei()),
+      uint25621.bnToUint256(amountInfo.amount.toWei()),
       receiver.address
     ]);
     return [call1, call2];
@@ -40408,9 +40727,9 @@ var SVKStrategy = class extends BaseStrategy {
       amountInfo.tokenInfo.address.eq(this.asset().address),
       "Withdraw token mismatch"
     );
-    const shares = await this.contract.call("convert_to_shares", [uint25620.bnToUint256(amountInfo.amount.toWei())]);
+    const shares = await this.contract.call("convert_to_shares", [uint25621.bnToUint256(amountInfo.amount.toWei())]);
     const call = this.contract.populate("request_redeem", [
-      uint25620.bnToUint256(shares.toString()),
+      uint25621.bnToUint256(shares.toString()),
       receiver.address,
       owner.address
     ]);
@@ -40601,7 +40920,7 @@ var SVKStrategy = class extends BaseStrategy {
 };
 
 // src/strategies/universal-lst-muliplier-strategy.tsx
-import { Contract as Contract16, uint256 as uint25621 } from "starknet";
+import { Contract as Contract17, uint256 as uint25622 } from "starknet";
 
 // src/strategies/universal-adapters/adapter-optimizer.ts
 var AdapterOptimizer = class {
@@ -40754,15 +41073,15 @@ var UniversalLstMultiplierStrategy = class _UniversalLstMultiplierStrategy exten
   async getLSTExchangeRate() {
     const vesuAdapter1 = this.getVesuSameTokenAdapter();
     const lstTokenInfo = vesuAdapter1._vesuAdapter.config.collateral;
-    const lstABI = new Contract16({
+    const lstABI = new Contract17({
       abi: erc4626_abi_default,
       address: lstTokenInfo.address.address,
       providerOrAccount: this.config.provider
     });
     const price = await lstABI.call("convert_to_assets", [
-      uint25621.bnToUint256(new Web3Number(1, lstTokenInfo.decimals).toWei())
+      uint25622.bnToUint256(new Web3Number(1, lstTokenInfo.decimals).toWei())
     ]);
-    const exchangeRate = Number(uint25621.uint256ToBN(price).toString()) / Math.pow(10, lstTokenInfo.decimals);
+    const exchangeRate = Number(uint25622.uint256ToBN(price).toString()) / Math.pow(10, lstTokenInfo.decimals);
     logger.verbose(`${this.getTag()}:: LST Exchange Rate: ${exchangeRate}`);
     return exchangeRate;
   }
@@ -41632,6 +41951,249 @@ var HyperLSTStrategies = [
   getStrategySettings("mRe7YIELD", "mRe7YIELD", hypermRe7YIELD, false, false)
 ];
 
+// src/strategies/vesu-extended-strategy/services/ltv-imbalance-rebalance-math.ts
+function ceilBtc(v, precision) {
+  const f = 10 ** precision;
+  return Math.ceil(v * f) / f;
+}
+function floorBtc(v, precision) {
+  const f = 10 ** precision;
+  return Math.floor(v * f) / f;
+}
+function isNegligible(btc, precision) {
+  return Math.abs(btc) < 10 ** -precision;
+}
+function computeExtIdealMargin(posBtc, leverage, price) {
+  return posBtc * price / leverage;
+}
+function computeExtDeficit(ext, price) {
+  return Math.max(0, computeExtIdealMargin(ext.positionBtc, ext.leverage, price) - ext.equity);
+}
+function computeVesuHF(vesu, price) {
+  const collateralUsd = vesu.positionBtc * price;
+  if (collateralUsd === 0) return Infinity;
+  const ltv = vesu.debt * vesu.debtPrice / collateralUsd;
+  if (ltv === 0) return Infinity;
+  return vesu.maxLTV / ltv;
+}
+function computeVesuDebtRepay(vesu, price) {
+  const targetLTV = vesu.maxLTV / vesu.targetHF;
+  const collateralUsd = vesu.positionBtc * price;
+  const requiredDebt = targetLTV * collateralUsd / vesu.debtPrice;
+  return Math.max(0, vesu.debt - requiredDebt);
+}
+function computeVesuTargetLTV(vesu) {
+  return vesu.maxLTV / vesu.targetHF;
+}
+function computeVesuGrowthCost(gapBtc, vesu, price) {
+  const targetLTV = computeVesuTargetLTV(vesu);
+  return gapBtc * price * (1 - targetLTV);
+}
+function computeVesuGrowthDebt(gapBtc, vesu, price) {
+  const targetLTV = computeVesuTargetLTV(vesu);
+  return gapBtc * price * targetLTV / vesu.debtPrice;
+}
+function computeVesuGrowthFromEquity(equityUsd, vesu, price) {
+  const targetLTV = computeVesuTargetLTV(vesu);
+  return equityUsd / (price * (1 - targetLTV));
+}
+function emptyDeltas() {
+  return {
+    dExtPosition: 0,
+    dVesuPosition: 0,
+    dVesuDebt: 0,
+    dExtAvlWithdraw: 0,
+    dExtUpnl: 0,
+    dVaUsd: 0,
+    dWalletUsd: 0,
+    dVesuBorrowCapacity: 0,
+    dTransferVesuToExt: 0
+  };
+}
+function mergeDeltas(a, b) {
+  return {
+    dExtPosition: a.dExtPosition + b.dExtPosition,
+    dVesuPosition: a.dVesuPosition + b.dVesuPosition,
+    dVesuDebt: a.dVesuDebt + b.dVesuDebt,
+    dExtAvlWithdraw: a.dExtAvlWithdraw + b.dExtAvlWithdraw,
+    dExtUpnl: a.dExtUpnl + b.dExtUpnl,
+    dVaUsd: a.dVaUsd + b.dVaUsd,
+    dWalletUsd: a.dWalletUsd + b.dWalletUsd,
+    dVesuBorrowCapacity: a.dVesuBorrowCapacity + b.dVesuBorrowCapacity,
+    dTransferVesuToExt: a.dTransferVesuToExt + b.dTransferVesuToExt
+  };
+}
+function drawFunds(need, keys, pool) {
+  const draws = {};
+  let unmet = need;
+  for (const k of keys) {
+    if (unmet <= 0) break;
+    const avail = pool[k];
+    if (avail <= 0) continue;
+    const take = Math.min(avail, unmet);
+    draws[k] = take;
+    pool[k] -= take;
+    unmet -= take;
+  }
+  return { draws, filled: need - unmet, unmet };
+}
+function sumKeys(draws, keys) {
+  return keys.reduce((s, k) => s + (draws[k] ?? 0), 0);
+}
+function applyDrawsToDeltas(d, draws, sign) {
+  d.dVaUsd += sign * (draws.vaUsd ?? 0);
+  d.dWalletUsd += sign * (draws.walletUsd ?? 0);
+  d.dVesuBorrowCapacity += sign * (draws.vesuBorrowCapacity ?? 0);
+  d.dExtAvlWithdraw += sign * (draws.extAvlWithdraw ?? 0);
+  d.dExtUpnl += sign * (draws.extUpnl ?? 0);
+}
+function fixExtMargin(ext, price, pool) {
+  const d = emptyDeltas();
+  const deficit = computeExtDeficit(ext, price);
+  if (deficit <= 0) return { d, unmet: 0 };
+  const { draws, filled, unmet } = drawFunds(deficit, ["walletUsd", "vaUsd", "vesuBorrowCapacity"], pool);
+  applyDrawsToDeltas(d, draws, -1);
+  d.dExtAvlWithdraw += filled;
+  const fromVesu = draws.vesuBorrowCapacity ?? 0;
+  if (fromVesu > 0) d.dTransferVesuToExt += fromVesu;
+  return { d, unmet };
+}
+function fixVesuMargin(vesu, price, pool, hfBuffer) {
+  const d = emptyDeltas();
+  const hf = computeVesuHF(vesu, price);
+  if (hf >= vesu.targetHF - hfBuffer) return { d, unmet: 0 };
+  const repayTokens = computeVesuDebtRepay(vesu, price);
+  const repayUsd = repayTokens * vesu.debtPrice;
+  const { draws, filled, unmet } = drawFunds(repayUsd, ["vaUsd", "walletUsd", "extAvlWithdraw", "extUpnl"], pool);
+  applyDrawsToDeltas(d, draws, -1);
+  d.dVesuDebt -= filled / vesu.debtPrice;
+  const fromExt = sumKeys(draws, ["extAvlWithdraw", "extUpnl"]);
+  if (fromExt > 0) d.dTransferVesuToExt -= fromExt;
+  return { d, unmet };
+}
+function phase1(ext, vesu, price, pool, config) {
+  const extResult = fixExtMargin(ext, price, pool);
+  const vesuResult = fixVesuMargin(vesu, price, pool, config.hfBuffer);
+  return {
+    deltas: mergeDeltas(extResult.d, vesuResult.d),
+    extDeficitRemaining: extResult.unmet,
+    vesuRepayRemaining: vesuResult.unmet
+  };
+}
+function solveUnifiedF(extPos, vesuPos, extEquity, vesuDebt, vesu, extLev, price) {
+  const targetLTV = computeVesuTargetLTV(vesu);
+  const k = 1 - targetLTV + 1 / extLev;
+  const totalEquity = extEquity + vesuPos * price - vesuDebt * vesu.debtPrice;
+  return totalEquity / (price * k);
+}
+function solveTransfer(vesuPos, vesuDebt, F, vesu, price) {
+  const targetLTV = computeVesuTargetLTV(vesu);
+  return vesuPos * price - vesuDebt * vesu.debtPrice - F * price * (1 - targetLTV);
+}
+function solveDebtRepay(vesuDebt, F, vesu, price) {
+  const targetLTV = computeVesuTargetLTV(vesu);
+  return vesuDebt - targetLTV * F * price / vesu.debtPrice;
+}
+function roundFinalPosition(extPos, vesuPos, rawF, precision) {
+  let fFromExt;
+  if (rawF < extPos) {
+    const closeExt = ceilBtc(extPos - rawF, precision);
+    fFromExt = extPos - closeExt;
+  } else {
+    const growExt = floorBtc(rawF - extPos, precision);
+    fFromExt = extPos + growExt;
+  }
+  let fFromVesu;
+  if (rawF < vesuPos) {
+    const closeVesu = ceilBtc(vesuPos - rawF, precision);
+    fFromVesu = vesuPos - closeVesu;
+  } else {
+    const growVesu = floorBtc(rawF - vesuPos, precision);
+    fFromVesu = vesuPos + growVesu;
+  }
+  return Math.max(0, Math.min(fFromExt, fFromVesu));
+}
+function phase2(extPos, vesuPos, extEquity, vesuDebt, vesu, extLev, price, pool, precision) {
+  const d = emptyDeltas();
+  const targetLTV = computeVesuTargetLTV(vesu);
+  const imbalance = extPos - vesuPos;
+  let fundedGrowthBtc = 0;
+  if (!isNegligible(imbalance, precision)) {
+    if (imbalance > 0) {
+      const equityCostUsd = computeVesuGrowthCost(imbalance, vesu, price);
+      const { draws, filled } = drawFunds(equityCostUsd, ["vaUsd", "walletUsd", "extAvlWithdraw", "extUpnl"], pool);
+      applyDrawsToDeltas(d, draws, -1);
+      const grownBtc = computeVesuGrowthFromEquity(filled, vesu, price);
+      d.dVesuPosition += grownBtc;
+      fundedGrowthBtc = grownBtc;
+      d.dVesuDebt += computeVesuGrowthDebt(grownBtc, vesu, price);
+      const fromExt = sumKeys(draws, ["extAvlWithdraw", "extUpnl"]);
+      if (fromExt > 0) d.dTransferVesuToExt -= fromExt;
+    } else {
+      const absImbalance = -imbalance;
+      const marginCostUsd = absImbalance * price / extLev;
+      const { draws, filled } = drawFunds(marginCostUsd, ["walletUsd", "vaUsd", "vesuBorrowCapacity"], pool);
+      applyDrawsToDeltas(d, draws, -1);
+      const grownBtc = filled * extLev / price;
+      d.dExtPosition += grownBtc;
+      fundedGrowthBtc = grownBtc;
+      const fromVesu = draws.vesuBorrowCapacity ?? 0;
+      if (fromVesu > 0) d.dTransferVesuToExt += fromVesu;
+    }
+  }
+  const effExtPos = extPos + d.dExtPosition;
+  const effVesuPos = vesuPos + d.dVesuPosition;
+  const effExtEquity = extEquity;
+  const effVesuDebt = vesuDebt + d.dVesuDebt;
+  const rawF = solveUnifiedF(effExtPos, effVesuPos, effExtEquity, effVesuDebt, vesu, extLev, price);
+  const cappedF = Math.min(rawF, Math.max(effExtPos, effVesuPos));
+  const maxGrowableTo = Math.max(effExtPos, effVesuPos);
+  const targetF = Math.max(0, Math.min(cappedF, maxGrowableTo));
+  const remainingImbalance = effExtPos - effVesuPos;
+  const extNeedsMore = effExtEquity < computeExtIdealMargin(effExtPos, extLev, price);
+  const vesuCurrentLTV = effVesuPos > 0 ? effVesuDebt * vesu.debtPrice / (effVesuPos * price) : 0;
+  const vesuNeedsMore = vesuCurrentLTV > targetLTV;
+  const needsFurtherAction = !isNegligible(remainingImbalance, precision) || extNeedsMore || vesuNeedsMore;
+  if (!needsFurtherAction) {
+    return d;
+  }
+  const F = roundFinalPosition(effExtPos, effVesuPos, targetF, precision);
+  const dx = F - effExtPos;
+  const dy = F - effVesuPos;
+  if (isNegligible(dx, precision) && isNegligible(dy, precision)) {
+    return d;
+  }
+  d.dExtPosition += dx;
+  d.dVesuPosition += dy;
+  const debtRepay = solveDebtRepay(effVesuDebt, F, vesu, price);
+  d.dVesuDebt -= debtRepay;
+  const T = solveTransfer(effVesuPos, effVesuDebt, F, vesu, price);
+  d.dTransferVesuToExt += T;
+  d.dExtAvlWithdraw += T;
+  return d;
+}
+function rebalance(inputs) {
+  const { ext, vesu, btcPrice, config } = inputs;
+  const pool = { ...inputs.funding };
+  const p1 = phase1(ext, vesu, btcPrice, pool, config);
+  const effExtPos = ext.positionBtc + p1.deltas.dExtPosition;
+  const effVesuPos = vesu.positionBtc + p1.deltas.dVesuPosition;
+  const effExtEquity = ext.equity + p1.deltas.dExtAvlWithdraw + p1.deltas.dExtUpnl;
+  const effVesuDebt = vesu.debt + p1.deltas.dVesuDebt;
+  const p2 = phase2(
+    effExtPos,
+    effVesuPos,
+    effExtEquity,
+    effVesuDebt,
+    vesu,
+    ext.leverage,
+    btcPrice,
+    pool,
+    config.positionPrecision
+  );
+  return mergeDeltas(p1.deltas, p2);
+}
+
 // src/strategies/vesu-extended-strategy/services/extended-vesu-state-manager.ts
 var RouteType = /* @__PURE__ */ ((RouteType2) => {
   RouteType2["WALLET_TO_EXTENDED"] = "WALLET_TO_EXTENDED";
@@ -41663,6 +42225,7 @@ var CaseCategory = /* @__PURE__ */ ((CaseCategory2) => {
   return CaseCategory2;
 })(CaseCategory || {});
 var CaseId = /* @__PURE__ */ ((CaseId2) => {
+  CaseId2["MANAGE_LTV"] = "MANAGE_LTV";
   CaseId2["LTV_VESU_LOW_TO_EXTENDED"] = "LTV_VESU_LOW_TO_EXTENDED";
   CaseId2["LTV_EXTENDED_PROFITABLE_AVAILABLE"] = "LTV_EXTENDED_PROFITABLE_AVAILABLE";
   CaseId2["LTV_EXTENDED_PROFITABLE_REALIZE"] = "LTV_EXTENDED_PROFITABLE_REALIZE";
@@ -41687,19 +42250,56 @@ function safeUsdcWeb3Number(value) {
   return new Web3Number(value.toFixed(USDC_TOKEN_DECIMALS), USDC_TOKEN_DECIMALS);
 }
 var CASE_ROUTE_TYPES = {
-  // LTV Rebalance — Vesu side
+  // LTV Rebalance — unified
+  ["MANAGE_LTV" /* MANAGE_LTV */]: [
+    "REALISE_PNL" /* REALISE_PNL */,
+    "EXTENDED_TO_WALLET" /* EXTENDED_TO_WALLET */,
+    "RETURN_TO_WAIT" /* RETURN_TO_WAIT */,
+    "WALLET_TO_VA" /* WALLET_TO_VA */,
+    "VESU_BORROW" /* VESU_BORROW */,
+    "VESU_REPAY" /* VESU_REPAY */,
+    "VA_TO_EXTENDED" /* VA_TO_EXTENDED */,
+    "VESU_MULTIPLY_DECREASE_LEVER" /* VESU_MULTIPLY_DECREASE_LEVER */,
+    "VESU_MULTIPLY_INCREASE_LEVER" /* VESU_MULTIPLY_INCREASE_LEVER */,
+    "AVNU_DEPOSIT_SWAP" /* AVNU_DEPOSIT_SWAP */,
+    "EXTENDED_DECREASE_LEVER" /* EXTENDED_DECREASE_LEVER */,
+    "EXTENDED_INCREASE_LEVER" /* EXTENDED_INCREASE_LEVER */,
+    // Second-phase VA / Extended funding after lever routes (same types may repeat).
+    "RETURN_TO_WAIT" /* RETURN_TO_WAIT */,
+    "WALLET_TO_VA" /* WALLET_TO_VA */,
+    "VA_TO_EXTENDED" /* VA_TO_EXTENDED */
+  ],
+  /** @deprecated */
   ["LTV_VESU_HIGH_USE_VA_OR_WALLET" /* LTV_VESU_HIGH_USE_VA_OR_WALLET */]: ["WALLET_TO_VA" /* WALLET_TO_VA */, "VESU_REPAY" /* VESU_REPAY */],
-  // use wallet to va if wallet has and va doesnt have enough
+  /** @deprecated */
   ["LTV_EXTENDED_PROFITABLE_AVAILABLE" /* LTV_EXTENDED_PROFITABLE_AVAILABLE */]: ["EXTENDED_TO_WALLET" /* EXTENDED_TO_WALLET */, "RETURN_TO_WAIT" /* RETURN_TO_WAIT */, "WALLET_TO_VA" /* WALLET_TO_VA */, "VESU_REPAY" /* VESU_REPAY */],
+  /** @deprecated */
   ["LTV_EXTENDED_PROFITABLE_REALIZE" /* LTV_EXTENDED_PROFITABLE_REALIZE */]: ["REALISE_PNL" /* REALISE_PNL */, "EXTENDED_TO_WALLET" /* EXTENDED_TO_WALLET */, "RETURN_TO_WAIT" /* RETURN_TO_WAIT */, "WALLET_TO_VA" /* WALLET_TO_VA */, "VESU_REPAY" /* VESU_REPAY */],
-  // LTV Rebalance — Extended side
+  /** @deprecated */
   ["LTV_EXTENDED_HIGH_USE_VA_OR_WALLET" /* LTV_EXTENDED_HIGH_USE_VA_OR_WALLET */]: ["VA_TO_EXTENDED" /* VA_TO_EXTENDED */, "WALLET_TO_EXTENDED" /* WALLET_TO_EXTENDED */],
+  /** @deprecated */
   ["LTV_VESU_LOW_TO_EXTENDED" /* LTV_VESU_LOW_TO_EXTENDED */]: ["VESU_BORROW" /* VESU_BORROW */, "VA_TO_EXTENDED" /* 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.
-  ["DEPOSIT_FRESH_VAULT" /* DEPOSIT_FRESH_VAULT */]: ["WALLET_TO_EXTENDED" /* WALLET_TO_EXTENDED */, "VA_TO_EXTENDED" /* VA_TO_EXTENDED */, "WALLET_TO_VA" /* WALLET_TO_VA */, "EXTENDED_TO_WALLET" /* EXTENDED_TO_WALLET */, "RETURN_TO_WAIT" /* RETURN_TO_WAIT */, "WALLET_TO_VA" /* WALLET_TO_VA */, "AVNU_DEPOSIT_SWAP" /* AVNU_DEPOSIT_SWAP */, "VESU_MULTIPLY_INCREASE_LEVER" /* VESU_MULTIPLY_INCREASE_LEVER */, "EXTENDED_INCREASE_LEVER" /* EXTENDED_INCREASE_LEVER */],
+  ["DEPOSIT_FRESH_VAULT" /* DEPOSIT_FRESH_VAULT */]: [
+    // May repeat after MANAGE_LTV (VA top-up → Extended → wait → levers).
+    "WALLET_TO_VA" /* WALLET_TO_VA */,
+    "VA_TO_EXTENDED" /* VA_TO_EXTENDED */,
+    "RETURN_TO_WAIT" /* RETURN_TO_WAIT */,
+    "VA_TO_EXTENDED" /* VA_TO_EXTENDED */,
+    "VESU_BORROW" /* VESU_BORROW */,
+    "WALLET_TO_EXTENDED" /* WALLET_TO_EXTENDED */,
+    "VA_TO_EXTENDED" /* VA_TO_EXTENDED */,
+    "WALLET_TO_VA" /* WALLET_TO_VA */,
+    "EXTENDED_TO_WALLET" /* EXTENDED_TO_WALLET */,
+    "RETURN_TO_WAIT" /* RETURN_TO_WAIT */,
+    "WALLET_TO_VA" /* WALLET_TO_VA */,
+    "AVNU_DEPOSIT_SWAP" /* AVNU_DEPOSIT_SWAP */,
+    "VESU_MULTIPLY_INCREASE_LEVER" /* VESU_MULTIPLY_INCREASE_LEVER */,
+    "EXTENDED_INCREASE_LEVER" /* EXTENDED_INCREASE_LEVER */
+  ],
   ["DEPOSIT_EXTENDED_AVAILABLE" /* DEPOSIT_EXTENDED_AVAILABLE */]: ["EXTENDED_TO_WALLET" /* EXTENDED_TO_WALLET */, "RETURN_TO_WAIT" /* RETURN_TO_WAIT */, "WALLET_TO_VA" /* WALLET_TO_VA */, "AVNU_DEPOSIT_SWAP" /* AVNU_DEPOSIT_SWAP */, "VESU_MULTIPLY_INCREASE_LEVER" /* VESU_MULTIPLY_INCREASE_LEVER */, "EXTENDED_INCREASE_LEVER" /* EXTENDED_INCREASE_LEVER */],
   ["DEPOSIT_VESU_BORROW_CAPACITY" /* DEPOSIT_VESU_BORROW_CAPACITY */]: ["VESU_BORROW" /* VESU_BORROW */, "VA_TO_EXTENDED" /* VA_TO_EXTENDED */, "RETURN_TO_WAIT" /* RETURN_TO_WAIT */, "AVNU_DEPOSIT_SWAP" /* AVNU_DEPOSIT_SWAP */, "VESU_MULTIPLY_INCREASE_LEVER" /* VESU_MULTIPLY_INCREASE_LEVER */, "EXTENDED_INCREASE_LEVER" /* EXTENDED_INCREASE_LEVER */],
   ["DEPOSIT_COMBINATION" /* DEPOSIT_COMBINATION */]: [],
@@ -41722,6 +42322,17 @@ var CASE_ROUTE_TYPES = {
   ["IMBALANCE_VESU_EXCESS_LONG_NO_FUNDS" /* IMBALANCE_VESU_EXCESS_LONG_NO_FUNDS */]: ["VESU_MULTIPLY_DECREASE_LEVER" /* VESU_MULTIPLY_DECREASE_LEVER */]
 };
 var CASE_DEFINITIONS = {
+  ["MANAGE_LTV" /* MANAGE_LTV */]: {
+    id: "MANAGE_LTV" /* MANAGE_LTV */,
+    category: "LTV_REBALANCE" /* 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"
+    ]
+  },
   ["LTV_VESU_LOW_TO_EXTENDED" /* LTV_VESU_LOW_TO_EXTENDED */]: {
     id: "LTV_VESU_LOW_TO_EXTENDED" /* LTV_VESU_LOW_TO_EXTENDED */,
     category: "LTV_REBALANCE" /* LTV_REBALANCE */,
@@ -41944,199 +42555,590 @@ function routeSummary(r) {
 }
 var SolveBudget = class {
   constructor(state) {
-    // should be same length as vesuPerPoolDebtDeltasToBorrow
-    // ── Budget tracking (populated by initBudget) ──────────────────────
-    this._vaUsd = 0;
-    this._walletUsd = 0;
-    this._extAvailWithdraw = 0;
-    this._extAvailUpnl = 0;
-    this._extAvailTrade = 0;
-    this._extPendingDeposit = 0;
-    this._vesuBorrowCapacity = 0;
-    this._totalUnused = 0;
-    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) => ({
+      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.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;
+    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 ? {
-      ...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)
+      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;
+    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. */
+  _usableFraction() {
+    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.
+   */
+  _rawTokenUsd(tb) {
+    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) {
+    return rawUsd * this._usableFraction();
+  }
+  /** Convert a buffered “usable” USD amount to raw nominal USD (inverse of {@link bufferedUsd}). */
+  rawUsdFromBuffered(bufferedUsd) {
+    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) {
+    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()
+      } : void 0,
+      vaultAssetBalance: this.vaultAssetBalance ? {
+        token: this.vaultAssetBalance.token.symbol,
+        amount: this.vaultAssetBalance.amount.toNumber()
+      } : void 0,
+      vaultUsdcBalance: this.vaultUsdcBalance ? {
+        token: this.vaultUsdcBalance.token.symbol,
+        amount: this.vaultUsdcBalance.amount.toNumber()
+      } : void 0,
+      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()
+      }))
+    };
+    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}` : void 0
+    );
+    console.log(
+      "vault asset balance",
+      aggregatedData.vaultAssetBalance ? `${aggregatedData.vaultAssetBalance.token}=${aggregatedData.vaultAssetBalance.amount}` : void 0
+    );
+    console.log(
+      "vault usdc balance",
+      aggregatedData.vaultUsdcBalance ? `${aggregatedData.vaultUsdcBalance.token}=${aggregatedData.vaultUsdcBalance.amount}` : void 0
+    );
+    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(", "));
+    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() {
-    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;
     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) {
+    if (factor <= 0 || factor >= 1) return;
+    const mult = 1 - factor;
+    const scaleTokenBalance = (tb) => {
+      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();
   }
-  // ── Read-only getters ────────────────────────────────────────────────
+  get 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() {
-    return this._vaUsd;
+    return this.bufferedTokenUsd(this.vaultAssetBalance) + this.bufferedTokenUsd(this.vaultUsdcBalance);
+  }
+  /** Buffered USD in VA strategy-asset bucket only. */
+  get vaAssetUsd() {
+    return this.bufferedTokenUsd(this.vaultAssetBalance);
+  }
+  /** Buffered USD in VA USDC bucket (0 when asset === USDC). */
+  get vaUsdcUsd() {
+    return this.bufferedTokenUsd(this.vaultUsdcBalance);
   }
   get walletUsd() {
-    return this._walletUsd;
+    return this.bufferedUsd(this._rawTokenUsd(this.walletBalance));
   }
   get vaWalletUsd() {
-    return this._vaUsd + this._walletUsd;
+    return this.vaUsd + this.walletUsd;
   }
   get extAvailWithdraw() {
-    return this._extAvailWithdraw;
+    const raw = this.extendedBalance?.availableForWithdrawal?.toNumber() ?? 0;
+    return this.bufferedUsd(raw);
   }
   get extAvailUpnl() {
-    return this._extAvailUpnl;
+    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() {
-    return this._extAvailTrade;
+    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() {
+    return this.extendedBalance?.pendingDeposit?.toNumber() ?? 0;
   }
+  /**
+   * Aggregate positive per-pool borrow headroom (USD). Repay/borrow routes update
+   * {@link vesuPerPoolDebtDeltasToBorrow}; no separate counter.
+   */
   get vesuBorrowCapacity() {
-    return this._vesuBorrowCapacity;
+    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() {
-    return this._totalUnused;
+    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() {
+    return this.unusedBalance.reduce((a, b) => a + this.bufferedTokenUsd(b), 0);
+  }
+  /** Read-only snapshot view for validation / logging. */
+  get unusedBalanceRows() {
+    return this.unusedBalance;
+  }
+  /** Read-only Vesu pool view for solve computations. */
+  get vesuPools() {
+    return this.vesuPoolStates;
+  }
+  /** Read-only Extended positions view for solve computations. */
+  get extendedPositionsView() {
+    return this.extendedPositions;
+  }
+  /** Read-only Extended balance view for diagnostics / margin checks. */
+  get extendedBalanceView() {
+    return this.extendedBalance;
+  }
+  /** Current debt deltas per pool (positive=borrow, negative=repay). */
+  get vesuDebtDeltas() {
+    return this.vesuPerPoolDebtDeltasToBorrow;
+  }
+  /** Per-pool rebalance flags derived from target HF checks. */
+  get vesuRebalanceFlags() {
+    return this.shouldVesuRebalance;
+  }
+  /** Raw USD in VA (USDC slot + asset slot); spend caps when executing transfers. */
+  _vaRawUsd() {
+    return this._rawTokenUsd(this.vaultUsdcBalance) + this._rawTokenUsd(this.vaultAssetBalance);
+  }
+  _walletRawUsd() {
+    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. */
+  _deductUsdFromTokenBalance(tb, usd) {
+    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
+    );
+  }
+  /** Add USD notional; infers price from current amount/usd when possible, else 1:1. */
+  _addUsdToTokenBalance(tb, usd) {
+    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)
+    );
   }
-  get extPendingDeposit() {
-    return this._extPendingDeposit;
+  /**
+   * Rebuilds {@link unusedBalance} from vault + wallet snapshots (same merge as refresh).
+   */
+  _recomputeUnusedBalance() {
+    const balanceMap = /* @__PURE__ */ new Map();
+    const merge = (b) => {
+      if (!b) return;
+      const key = b.token.address.toString();
+      const row = {
+        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);
+      }
+    };
+    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) {
-    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;
-  }
-  addToVA(amount) {
-    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}`);
-  }
-  spendWallet(desired) {
-    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;
+  /**
+   * Spend VA **raw** USD (up to {@link vaRawUsd}). Prefer {@link vaultUsdcBalance} when present, then {@link vaultAssetBalance}.
+   */
+  spendVA(rawDesired) {
+    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;
   }
-  addToWallet(amount) {
-    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}`);
+  /**
+   * Spend nominal/raw USD from VA (e.g. Vesu repay, on-chain USDC). Does not apply the safety buffer to the cap.
+   */
+  spendVaRawUsd(rawUsdDesired) {
+    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;
   }
-  spendVAWallet(desired) {
-    let remaining = Math.max(0, desired);
+  /**
+   * Add **raw nominal USD** to VA (borrow proceeds, wallet→VA in raw USDC, etc.).
+   */
+  addToVA(rawUsd) {
+    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}`);
+  }
+  spendWallet(rawDesired) {
+    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;
+  }
+  /** Add **raw nominal USD** to the operator wallet balance (e.g. Extended→wallet withdrawal). */
+  addToWallet(rawUsd) {
+    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) {
+    let remaining = Math.max(0, rawDesired);
     const vaSpent = this.spendVA(remaining);
     remaining -= vaSpent;
     const walletSpent = this.spendWallet(remaining);
     return vaSpent + walletSpent;
   }
-  _updateExtAvailWithdraw(desired, isSpend) {
-    let amount = desired;
-    assert(amount > 0, "SolveBudget::_updateExtAvailWithdraw amount must be positive");
+  _updateExtAvailWithdraw(desiredRaw, isSpend) {
+    assert(desiredRaw > 0, "SolveBudget::_updateExtAvailWithdraw amount must be positive");
+    let rawDelta;
     if (isSpend) {
-      amount = Math.min(this._extAvailWithdraw, Math.max(0, desired));
-      amount = -amount;
+      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;
     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;
   }
-  _updateExtAvailUpnl(desired, isSpend) {
-    let amount = desired;
-    assert(amount > 0, "SolveBudget::_updateExtAvailUpnl amount must be positive");
+  _updateExtAvailUpnl(desiredRaw, isSpend) {
+    assert(desiredRaw > 0, "SolveBudget::_updateExtAvailUpnl amount must be positive");
+    let rawDelta;
     if (isSpend) {
-      amount = Math.min(this._extAvailUpnl, Math.max(0, desired));
-      amount = -amount;
+      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;
     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);
-    }
-    logger.debug(`SolveBudget::updateExtAvailUpnl amount=${amount}, extAvailUpnl=${this._extAvailUpnl}, totalUnused=${this._totalUnused}`);
-    return amount;
-  }
-  spendExtAvailTrade(desired) {
-    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}`);
+      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 rawDelta=${rawDelta}, extAvailUpnl=${this.extAvailUpnl}, totalUnused=${this.totalUnused}`);
+    return rawDelta;
+  }
+  spendExtAvailTrade(rawDesired) {
+    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) {
-    return this._updateExtAvailUpnl(desired, true);
+  // simply reduces available amounts, but maintains equity and balance.
+  spendExtAvailTradeToEquityOnly(rawDesired) {
+    const used = this._updateExtAvailWithdraw(rawDesired, true);
+    const remaining = rawDesired - Math.abs(used);
+    const usedUpnl = remaining > 0 ? this._updateExtAvailUpnl(remaining, true) : 0;
+    if (this.extendedBalance) {
+      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) {
+    return this._updateExtAvailWithdraw(rawDesired, true);
+  }
+  spendExtAvailUpnl(rawDesired) {
+    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) {
+    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.
+   */
+  _extendedMarginRequirementUsd() {
+    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;
+  }
+  /** How much more equity is needed before deposits should increase withdraw / trade availability. */
+  _extendedEquityShortfallUsd() {
+    if (!this.extendedBalance) return 0;
+    const req = this._extendedMarginRequirementUsd();
+    const eq = this.extendedBalance.equity.toNumber();
+    return Math.max(0, req - eq);
   }
-  addToExtAvailTrade(amount) {
-    this._updateExtAvailWithdraw(amount, false);
-    logger.debug(`SolveBudget::addToExtAvailTrade amount=${amount}, extAvailTrade=${this._extAvailTrade}, totalUnused=${this._totalUnused}`);
+  /**
+   * 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) {
+    assert(rawUsd >= 0, "SolveBudget::addToExtAvailTrade amount must be non-negative");
+    if (rawUsd <= CASE_THRESHOLD_USD) return;
+    if (!this.extendedBalance) {
+      logger.warn("SolveBudget::addToExtAvailTrade skipped \u2014 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) {
-    const used = Math.min(this._vesuBorrowCapacity, Math.max(0, desired));
-    this._vesuBorrowCapacity -= used;
-    this._totalUnused -= used;
+    const used = Math.min(this.vesuBorrowCapacity, Math.max(0, desired));
     let spendsByPool = [];
     for (let index = 0; index < this.vesuPerPoolDebtDeltasToBorrow.length; index++) {
       const d = this.vesuPerPoolDebtDeltasToBorrow[index];
@@ -42147,13 +43149,12 @@ var SolveBudget = class {
       this.vesuPoolStates[index].debtUsdValue = this.vesuPoolStates[index].debtAmount.toNumber() * this.vesuPoolStates[index].debtPrice;
       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) {
     assert(desired > 0, "SolveBudget::repayVesuBorrowCapacity desired must be positive");
     const used = desired;
-    this._vesuBorrowCapacity += used;
     const spendsByPool = [];
     for (let index = 0; index < this.vesuPerPoolDebtDeltasToBorrow.length; index++) {
       const d = this.vesuPerPoolDebtDeltasToBorrow[index];
@@ -42163,7 +43164,7 @@ var SolveBudget = class {
       this.vesuPoolStates[index].debtAmount = safeUsdcWeb3Number(this.vesuPoolStates[index].debtAmount.toNumber() - repaid);
       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 };
   }
   // ── State mutation ──────────────────────────────────────────────────
@@ -42185,13 +43186,21 @@ var SolveBudget = class {
     pool.debtUsdValue = pool.debtAmount.toNumber() * pool.debtPrice;
     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, sizeDelta) {
-    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, sizeDelta, collateralPriceUsd) {
+    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) {
@@ -42202,6 +43211,56 @@ var SolveBudget = class {
         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 === void 0 || 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. */
+  _lockExtendedMarginUsd(lockedUsd) {
+    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);
     }
   }
   /**
@@ -42229,6 +43288,23 @@ var SolveBudget = class {
     return output;
   }
 };
+function createSolveBudgetFromRawState(params) {
+  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;
+}
 var ExtendedSVKVesuStateManager = class {
   constructor(config) {
     this._tag = "ExtendedSVKVesuStateManager";
@@ -42264,7 +43340,7 @@ var ExtendedSVKVesuStateManager = class {
       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);
     return result;
@@ -42279,30 +43355,44 @@ var ExtendedSVKVesuStateManager = class {
   async _refresh() {
     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
     });
     const totalUnusedUsd = unusedBalance.reduce(
@@ -42314,10 +43404,14 @@ var ExtendedSVKVesuStateManager = class {
     );
   }
   // 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). */
+  _vaultAssetAndUsdcAreSameToken() {
+    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.
    */
-  async _fetchVaultAllocatorBalance() {
+  async _fetchVaultAllocatorAssetBalance() {
     const { assetToken, vaultAllocator, networkConfig, pricer } = this._config;
     const balance = await new ERC20(networkConfig).balanceOf(
       assetToken.address,
@@ -42329,20 +43423,38 @@ var ExtendedSVKVesuStateManager = class {
     return { token: assetToken, amount: balance, usdValue };
   }
   /**
-   * 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).
+   */
+  async _fetchVaultAllocatorUsdcBalanceIfDistinct() {
+    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.
    */
-  _computeUnusedBalances(vaultAllocatorBalance, walletBalance) {
+  _computeUnusedBalances(vaultAssetBalance, vaultUsdcBalance, walletBalance) {
     const balanceMap = /* @__PURE__ */ new Map();
-    balanceMap.set(vaultAllocatorBalance.token.address.toString(), {
-      token: vaultAllocatorBalance.token,
-      amount: vaultAllocatorBalance.amount,
-      usdValue: vaultAllocatorBalance.usdValue
-    });
+    const put = (tb) => {
+      balanceMap.set(tb.token.address.toString(), {
+        token: tb.token,
+        amount: tb.amount,
+        usdValue: tb.usdValue
+      });
+    };
+    put(vaultAssetBalance);
+    if (vaultUsdcBalance) put(vaultUsdcBalance);
     const key = walletBalance.token.address.toString();
     const existing = balanceMap.get(key);
     if (existing) {
@@ -42361,30 +43473,29 @@ var ExtendedSVKVesuStateManager = class {
     return Array.from(balanceMap.values());
   }
   /**
-   * 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}).
    */
   async _fetchWalletBalances() {
     const {
       networkConfig,
       pricer,
       walletAddress,
-      assetToken,
-      usdceToken
+      usdcToken
     } = this._config;
     const erc20 = new ERC20(networkConfig);
-    const [usdceBalance, usdcePrice] = await Promise.all([
+    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,
-      usdValue: Number(usdceBalance.toFixed(usdceToken.decimals)) * usdcePrice.price
+      token: usdcToken,
+      amount: balance,
+      usdValue: Number(balance.toFixed(usdcToken.decimals)) * tokenPrice.price
     };
   }
   /**
@@ -42502,12 +43613,12 @@ var ExtendedSVKVesuStateManager = class {
    * finite, sensible values. Throws on invalid state.
    */
   _validateRefreshedState() {
-    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}]`
@@ -42527,7 +43638,7 @@ var ExtendedSVKVesuStateManager = class {
     }
   }
   _validateVesuPoolPricesOrThrow() {
-    for (const pool of this._budget.vesuPoolStates) {
+    for (const pool of this._budget.vesuPools) {
       const poolLabel = pool.poolId.shortString();
       this._assertPositiveFinite(
         pool.collateralPrice,
@@ -42540,8 +43651,8 @@ var ExtendedSVKVesuStateManager = class {
     }
   }
   _validateExtendedBalanceOrThrow() {
-    if (!this._budget.extendedBalance) return;
-    const { equity, availableForTrade } = this._budget.extendedBalance;
+    if (!this._budget.extendedBalanceView) return;
+    const { equity, availableForTrade } = this._budget.extendedBalanceView;
     if (!Number.isFinite(equity.toNumber()) || !Number.isFinite(availableForTrade.toNumber())) {
       throw new Error(
         `${this._tag}: Extended balance contains non-finite values \u2014 equity: ${equity.toNumber()}, availableForTrade: ${availableForTrade.toNumber()}`
@@ -42580,18 +43691,26 @@ var ExtendedSVKVesuStateManager = class {
     );
   }
   /**
-   * 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}).
    */
   _computeTotalInvestableAmount() {
-    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 })))}`
+      `${this._tag}::_computeTotalInvestableAmount unusedBalances=${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);
   }
@@ -42622,7 +43741,7 @@ var ExtendedSVKVesuStateManager = class {
     if (denominator === 0) {
       throw new Error(`${this._tag}: Denominator is zero`);
     }
-    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));
     const numerator = vesuLeverage * distributableAmount.toNumber() + totalVesuExposureUsd.toNumber() - totalExtendedExposureUsd.toNumber();
@@ -42634,8 +43753,6 @@ var ExtendedSVKVesuStateManager = class {
       distributableAmount.minus(extendedAllocationUsd).toFixed(USDC_TOKEN_DECIMALS),
       USDC_TOKEN_DECIMALS
     );
-    const perPoolDebtDeltasToBorrow = this._budget.vesuPerPoolDebtDeltasToBorrow;
-    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));
     if (!isRecursive) {
@@ -42654,14 +43771,17 @@ var ExtendedSVKVesuStateManager = class {
    * by existing collateral value, then converts each share to collateral
    * token units.
    */
-  _computePerPoolCollateralDeltas(vesuAllocationUsd, perPoolDebtDeltasToBorrow) {
+  _computePerPoolCollateralDeltas(vesuAllocationUsd) {
     const vesuLeverage = calculateVesuLeverage();
-    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,
@@ -42671,12 +43791,12 @@ var ExtendedSVKVesuStateManager = class {
         _poolCollateralDelta.toFixed(COLLATERAL_PRECISION),
         pool.collateralToken.decimals
       );
-      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
@@ -42689,7 +43809,7 @@ var ExtendedSVKVesuStateManager = class {
    * Multi-pool cases split proportionally by current collateral USD value.
    */
   _computePoolCollateralShare(pool, totalCollateral, totalVesuAllocation) {
-    const isSinglePoolOrZeroTotal = this._budget.vesuPoolStates.length === 1 || totalCollateral.toNumber() === 0;
+    const isSinglePoolOrZeroTotal = this._budget.vesuPools.length === 1 || totalCollateral.toNumber() === 0;
     if (isSinglePoolOrZeroTotal) return totalVesuAllocation;
     const poolWeight = pool.collateralAmount.dividedBy(totalCollateral);
     return new Web3Number(
@@ -42726,8 +43846,8 @@ var ExtendedSVKVesuStateManager = class {
    */
   _computeTargetExtendedExposure(vesuDeltas) {
     let totalExposureCollateral = new Web3Number(0, USDC_TOKEN_DECIMALS);
-    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()}`
@@ -42745,7 +43865,7 @@ var ExtendedSVKVesuStateManager = class {
     );
   }
   _hasNoExtendedPositions() {
-    return this._budget.extendedPositions.length === 0;
+    return this._budget.extendedPositionsView.length === 0;
   }
   /**
    * Creates a single-element delta array for the default instrument
@@ -42756,7 +43876,7 @@ var ExtendedSVKVesuStateManager = class {
       {
         instrument: this._config.extendedAdapter.config.extendedMarketName,
         delta: new Web3Number(
-          delta.toFixed(COLLATERAL_PRECISION),
+          delta.toFixedRoundDown(COLLATERAL_PRECISION),
           USDC_TOKEN_DECIMALS
         )
       }
@@ -42768,7 +43888,7 @@ var ExtendedSVKVesuStateManager = class {
    */
   _distributeExposureDeltaAcrossPositions(totalDelta) {
     const totalExposure = this._totalExtendedExposure();
-    return this._budget.extendedPositions.map((position) => {
+    return this._budget.extendedPositionsView.map((position) => {
       const share = this._positionExposureShareFraction(
         position,
         totalExposure
@@ -42776,7 +43896,7 @@ var ExtendedSVKVesuStateManager = class {
       return {
         instrument: position.instrument,
         delta: new Web3Number(
-          totalDelta.multipliedBy(share).toFixed(COLLATERAL_PRECISION),
+          totalDelta.multipliedBy(share).toFixedRoundDown(COLLATERAL_PRECISION),
           USDC_TOKEN_DECIMALS
         )
       };
@@ -42788,7 +43908,7 @@ var ExtendedSVKVesuStateManager = class {
    * or when total exposure is zero.
    */
   _positionExposureShareFraction(position, totalExposure) {
-    const isSingleOrZero = totalExposure.toNumber() === 0 || this._budget.extendedPositions.length === 1;
+    const isSingleOrZero = totalExposure.toNumber() === 0 || this._budget.extendedPositionsView.length === 1;
     if (isSingleOrZero) return 1;
     return position.valueUsd.dividedBy(totalExposure).toNumber();
   }
@@ -42800,7 +43920,10 @@ var ExtendedSVKVesuStateManager = class {
    * Positive = need to deposit more, negative = can withdraw excess.
    */
   _computeExtendedDepositDelta(extendedAllocationUsd) {
-    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.minus(currentAvailableForTrade).toFixed(USDC_TOKEN_DECIMALS),
       USDC_TOKEN_DECIMALS
@@ -42808,8 +43931,8 @@ var ExtendedSVKVesuStateManager = class {
   }
   _computeVesuDepositAmount(vesuDeltas) {
     let totalVesuCollateral = new Web3Number(0, USDC_TOKEN_DECIMALS);
-    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));
@@ -42854,13 +43977,17 @@ var ExtendedSVKVesuStateManager = class {
     for (const route of spendsByPool) {
       routes.push({ type: "VESU_REPAY" /* VESU_REPAY */, ...route, priority: routes.length });
     }
-    this._budget.spendVA(used);
+    this._budget.spendVaRawUsd(used);
   }
-  _buildVesuBorrowRoutes(totalUsd, routes) {
+  _buildVesuBorrowRoutes(totalUsd, routes, opts) {
     let borrowable = this._budget.vesuBorrowCapacity;
+    if (opts?.maxBorrowUsd !== void 0) {
+      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: "VESU_BORROW" /* VESU_BORROW */, ...route, priority: routes.length });
     }
@@ -42916,9 +44043,9 @@ var ExtendedSVKVesuStateManager = class {
   //     });
   // }
   _getWalletToVARoute(tryAmount, routes) {
-    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 = { type: "WALLET_TO_VA" /* WALLET_TO_VA */, amount: safeUsdcWeb3Number(walletUsed), priority: routes.length };
       routes.push(route);
@@ -42927,9 +44054,9 @@ var ExtendedSVKVesuStateManager = class {
     return { routes, remaining: tryAmount };
   }
   _getWalletToEXTENDEDRoute(tryAmount, routes, shouldAddWaitRoute = true) {
-    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: "WALLET_TO_EXTENDED" /* WALLET_TO_EXTENDED */, amount: safeUsdcWeb3Number(walletUsed), priority: routes.length });
       if (shouldAddWaitRoute) {
@@ -42940,9 +44067,9 @@ var ExtendedSVKVesuStateManager = class {
     return { routes, remaining: tryAmount };
   }
   _getVAToEXTENDEDRoute(tryAmount, routes, shouldAddWaitRoute = true) {
-    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);
       const route = { type: "VA_TO_EXTENDED" /* VA_TO_EXTENDED */, amount: safeUsdcWeb3Number(vaUsed), priority: routes.length };
       routes.push(route);
@@ -42955,40 +44082,42 @@ var ExtendedSVKVesuStateManager = class {
   }
   _getExtendedToWalletRoute(tryAmount, routes, shouldAddWaitRoute = true) {
     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 = { type: "EXTENDED_TO_WALLET" /* 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 = { type: "EXTENDED_TO_WALLET" /* EXTENDED_TO_WALLET */, amount: safeUsdcWeb3Number(rawSpend), priority: routes.length };
     routes.push(route);
     if (shouldAddWaitRoute) {
       routes.push({ type: "RETURN_TO_WAIT" /* RETURN_TO_WAIT */, priority: routes.length });
     }
-    return { routes, remaining: tryAmount - Math.abs(extWithdrawUsed) };
+    return { routes, remaining: tryAmount - rawSpend };
   }
   _getWALLETToVARoute(tryAmount, routes) {
     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 };
-    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 = { type: "WALLET_TO_VA" /* WALLET_TO_VA */, amount: safeUsdcWeb3Number(walletUsed), priority: routes.length };
     routes.push(route);
     return { routes, remaining: tryAmount - walletUsed };
   }
   _getUpnlRoute(tryAmount, routes) {
-    const upnl = this._budget.extendedBalance?.unrealisedPnl?.toNumber() ?? 0;
-    const usableAmount = Math.min(tryAmount, upnl);
-    if (usableAmount <= CASE_THRESHOLD_USD) return { routes, remaining: tryAmount };
-    const upnlUsed = this._budget.spendExtAvailUpnl(usableAmount);
-    this._budget.addToExtAvailTrade(upnlUsed);
-    assert(this._budget.extendedPositions.length == 1, "SolveBudget::_getUpnlRoute: extendedPositions length must be 1");
+    const rawUpnl = this._budget.extAvailUpnl;
+    const usableRaw = Math.min(tryAmount, rawUpnl);
+    if (usableRaw <= 0) return { routes, remaining: tryAmount };
+    this._budget.spendExtAvailUpnl(usableRaw);
+    this._budget.addToExtAvailTrade(usableRaw);
+    assert(this._budget.extendedPositionsView.length == 1, "SolveBudget::_getUpnlRoute: extendedPositions length must be 1");
     routes.push({
       type: "REALISE_PNL" /* REALISE_PNL */,
-      amount: safeUsdcWeb3Number(upnlUsed),
-      instrument: this._budget.extendedPositions[0].instrument,
+      amount: safeUsdcWeb3Number(usableRaw),
+      instrument: this._budget.extendedPositionsView[0].instrument,
       priority: routes.length
     });
-    return { routes, remaining: tryAmount - upnlUsed };
+    return { routes, remaining: tryAmount - usableRaw };
   }
   // ── Sub-classifiers ────────────────────────────────────────────────────
   // Each sub-classifier builds routes directly from contextual data.
@@ -43003,7 +44132,7 @@ var ExtendedSVKVesuStateManager = class {
     const instrument = this._config.extendedAdapter.config.extendedMarketName ?? "BTC-USD";
     const routes = [];
     let remaining = withdrawAmount.toNumber();
-    const vaUsed = this._budget.spendVA(Math.min(this._budget.vaUsd, remaining));
+    const vaUsed = this._budget.spendVA(remaining);
     remaining -= vaUsed;
     let totalExtUsed = 0;
     if (remaining > CASE_THRESHOLD_USD) {
@@ -43026,48 +44155,90 @@ var ExtendedSVKVesuStateManager = class {
       totalExtUsed = usableWithrawAmount + upnlUsed;
     }
     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");
-      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 withdrawAmount2 = vesuAllocationUsd.dividedBy(avgCollPrice);
-        withdrawAmount2.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) => {
+        const factor = 10 ** COLLATERAL_PRECISION;
+        return Math.ceil(x * factor) / factor;
+      };
+      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;
+        }
+      }
+      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(n.toFixed(6));
+      if (vesuBtcDelta > 0) {
+        const totalVesuBtcSigned = -vesuBtcDelta;
+        const targetLtv = 1 - 1 / vesuLeverage;
+        const debtDelta = r6(totalVesuBtcSigned * avgCollPrice * targetLtv);
+        const marginBtc = 0;
+        const swappedBtc = Number(vesuBtcDelta.toFixed(COLLATERAL_PRECISION));
         routes.push({
           type: "VESU_MULTIPLY_DECREASE_LEVER" /* VESU_MULTIPLY_DECREASE_LEVER */,
           poolId: vesuAdapter.config.poolId,
           collateralToken: vesuAdapter.config.collateral,
-          marginAmount: withdrawAmount2,
-          swappedCollateralAmount: new Web3Number(vesuPositionDelta, vesuAdapter.config.collateral.decimals).minus(withdrawAmount2),
+          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
         });
-        this._budget.applyVesuDelta(vesuAdapter.config.poolId, vesuAdapter.config.collateral, vesuAdapter.config.debt, new Web3Number(vesuPositionDelta, USDC_TOKEN_DECIMALS), new Web3Number(debtDelta, USDC_TOKEN_DECIMALS));
-        if (vesuAllocationUsd.toNumber() < -CASE_THRESHOLD_USD) {
-          const swapAmount = new Web3Number((vesuAllocationUsd.toNumber() / avgCollPrice * 0.998).toFixed(6), USDC_TOKEN_DECIMALS);
-          routes.push({
-            type: "AVNU_WITHDRAW_SWAP" /* AVNU_WITHDRAW_SWAP */,
-            fromToken: vesuAdapter.config.collateral.symbol,
-            // add buffer to avoid rounding errors
-            fromAmount: swapAmount,
-            toToken: vesuAdapter.config.debt.symbol,
-            priority: routes.length
-          });
-          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) {
+      if (extBtcDelta > 0) {
         routes.push({
           type: "EXTENDED_DECREASE_LEVER" /* 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;
       }
     }
     if (totalExtUsed > CASE_THRESHOLD_USD) {
@@ -43100,56 +44271,231 @@ var ExtendedSVKVesuStateManager = class {
    *
    * Design: accumulate all ext-to-wallet moves, add transfer routes at the end (principle #3).
    */
-  _classifyLtvVesu() {
-    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).
+   */
+  _classifyLTV() {
+    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}`);
-    const allHealthLTVs = this._budget.shouldVesuRebalance.every((shouldReb) => !shouldReb);
-    if (debtDeltaSum >= -CASE_THRESHOLD_USD || allHealthLTVs) return [];
-    const needed = Math.abs(debtDeltaSum);
-    const routes = [];
-    let remaining = needed;
-    let totalExtUsed = 0;
-    let caseId = "LTV_VESU_HIGH_USE_VA_OR_WALLET" /* LTV_VESU_HIGH_USE_VA_OR_WALLET */;
-    const vaUsed = this._budget.spendVA(Math.min(this._budget.vaUsd, remaining));
-    remaining -= vaUsed;
-    if (remaining > CASE_THRESHOLD_USD) {
-      const { remaining: walletToVaRemaining } = this._getWALLETToVARoute(remaining, routes);
-      remaining = walletToVaRemaining;
-    }
-    if (remaining > CASE_THRESHOLD_USD) {
-      const usableWithdrawAmount = Math.min(remaining, this._budget.extAvailWithdraw);
-      remaining -= usableWithdrawAmount;
-      let upnlUsed = 0;
-      if (remaining > CASE_THRESHOLD_USD) {
-        const { remaining: upnlRemaining } = this._getUpnlRoute(remaining, routes);
-        upnlUsed = remaining - upnlRemaining;
-        remaining = upnlRemaining;
-        caseId = "LTV_EXTENDED_PROFITABLE_REALIZE" /* LTV_EXTENDED_PROFITABLE_REALIZE */;
-      } else {
-        caseId = "LTV_EXTENDED_PROFITABLE_AVAILABLE" /* LTV_EXTENDED_PROFITABLE_AVAILABLE */;
-      }
-      totalExtUsed = usableWithdrawAmount + upnlUsed;
-    }
-    if (remaining > CASE_THRESHOLD_USD) {
-      throw new Error(`${this._tag}: Insufficient funds to cover margin needs`);
-    }
-    if (totalExtUsed > CASE_THRESHOLD_USD) {
-      this._getExtendedToWalletRoute(totalExtUsed, routes);
-      this._getWALLETToVARoute(totalExtUsed, routes);
-    }
-    this._buildVesuRepayRoutes(needed - remaining, routes);
+    const routes = this._buildLtvRoutesFromRebalanceDeltas(d);
+    if (routes.length === 0) return [];
+    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);
     routes.forEach((r, i) => {
       r.priority = i;
     });
     return [{
-      case: CASE_DEFINITIONS[caseId],
-      additionalArgs: { amount: safeUsdcWeb3Number(needed) },
+      case: CASE_DEFINITIONS["MANAGE_LTV" /* MANAGE_LTV */],
+      additionalArgs: { amount: safeUsdcWeb3Number(amountUsd) },
       routes
     }];
   }
+  _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;
+    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
+      }
+    };
+  }
+  _isLtvRebalanceNoop(d) {
+    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).
+   */
+  _buildLtvRoutesFromRebalanceDeltas(d) {
+    const routes = [];
+    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;
+    if (d.dVesuPosition < -btcEps) {
+      const xBtc = -d.dVesuPosition;
+      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));
+      }
+      const swapLegMaxRepayUsd = swappedBtc * price * debtPrice;
+      const debtUsdFallback = swappedBtc * price * targetLtv;
+      let debtTokenDelta;
+      if (d.dVesuDebt < 0) {
+        const needRepayUsd = -d.dVesuDebt * debtPrice;
+        const multiplyRepayUsd = Math.min(needRepayUsd, swapLegMaxRepayUsd);
+        debtTokenDelta = -(multiplyRepayUsd / debtPrice);
+      } else {
+        debtTokenDelta = -debtUsdFallback;
+      }
+      const debtAmtW3 = new Web3Number(debtTokenDelta.toFixed(USDC_TOKEN_DECIMALS), USDC_TOKEN_DECIMALS);
+      multiplyDebtRepayUsd = Math.abs(debtTokenDelta) * debtPrice;
+      routes.push({
+        type: "VESU_MULTIPLY_DECREASE_LEVER" /* 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
+      });
+      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: "AVNU_DEPOSIT_SWAP" /* 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: "VESU_MULTIPLY_INCREASE_LEVER" /* 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
+      });
+      this._budget.applyVesuDelta(
+        vesuAdapter.config.poolId,
+        vesuAdapter.config.collateral,
+        vesuAdapter.config.debt,
+        collateralDelta,
+        debtDeltaTokens
+      );
+    }
+    if (d.dExtPosition < -btcEps) {
+      const amt = new Web3Number(d.dExtPosition.toFixed(COLLATERAL_PRECISION), 8);
+      routes.push({
+        type: "EXTENDED_DECREASE_LEVER" /* EXTENDED_DECREASE_LEVER */,
+        amount: amt,
+        instrument,
+        priority: routes.length
+      });
+      this._budget.applyExtendedExposureDelta(instrument, amt, price);
+    } else if (d.dExtPosition > btcEps) {
+      const amt = new Web3Number(d.dExtPosition.toFixed(COLLATERAL_PRECISION), 8);
+      routes.push({
+        type: "EXTENDED_INCREASE_LEVER" /* EXTENDED_INCREASE_LEVER */,
+        amount: amt,
+        instrument,
+        priority: routes.length
+      });
+      this._budget.applyExtendedExposureDelta(instrument, amt, price);
+    }
+    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;
+    }
+    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;
+    }
+    const walletPull = Math.abs(Math.min(0, d.dWalletUsd));
+    const walletToVaUsd = walletPull + extToWalletUsd;
+    if (walletToVaUsd > CASE_THRESHOLD_USD) {
+      this._getWALLETToVARoute(walletToVaUsd, routes);
+    }
+    if (d.dVesuBorrowCapacity < -CASE_THRESHOLD_USD) {
+      this._buildVesuBorrowRoutes(Math.abs(d.dVesuBorrowCapacity), 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 ───────────────────────────────────────────
   /**
    * LTV_EXTENDED_PROFITABLE_AVAILABLE:
@@ -43226,60 +44572,7 @@ var ExtendedSVKVesuStateManager = class {
   //   routes.forEach((r, i) => { r.priority = i; });
   //   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
-   */
-  _classifyLtvExtended() {
-    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 = "LTV_EXTENDED_HIGH_USE_VA_OR_WALLET" /* LTV_EXTENDED_HIGH_USE_VA_OR_WALLET */;
-    let remaining = marginNeeded;
-    const routes = [];
-    if (this._budget.vaWalletUsd > CASE_THRESHOLD_USD && remaining > CASE_THRESHOLD_USD) {
-      const use = Math.min(this._budget.vaWalletUsd, remaining);
-      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;
-      }
-    }
-    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 = "LTV_VESU_LOW_TO_EXTENDED" /* 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 ───────────────────────────────────────
   /**
    * LTV_EXTENDED_HIGH_USE_VA_OR_WALLET:
@@ -43346,6 +44639,62 @@ var ExtendedSVKVesuStateManager = class {
   //   return routes;
   // }
   // ! todo implement max lever amount per execution cycle
+  _rebalanceFunds({
+    extAvlWithdraw,
+    extUpnl,
+    vaUsd,
+    walletUsd,
+    vesuBorrowCapacity,
+    vesuLeverage,
+    extendedLeverage
+  }) {
+    const total = extAvlWithdraw + extUpnl + vaUsd + walletUsd + vesuBorrowCapacity;
+    const extendedTarget = total / (1 + extendedLeverage / vesuLeverage);
+    const extendedInitial = extAvlWithdraw + extUpnl;
+    let delta = extendedTarget - extendedInitial;
+    let dExtAvlWithdraw = 0, dExtUpnl = 0, dVaUsd = 0, dWalletUsd = 0, dVesuBorrowCapacity = 0;
+    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;
+      const received = delta - need;
+      const eco1Sum = extAvlWithdraw + extUpnl;
+      if (eco1Sum >= 0) {
+        dExtAvlWithdraw += received;
+      } else {
+        throw new Error(`${this._tag}: Unexpected case`);
+      }
+      if (need > 0) {
+        throw new Error(`${this._tag}: Insufficient funds to cover margin needs`);
+      }
+    } 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;
+      const eco2Sum = vaUsd + walletUsd + vesuBorrowCapacity;
+      if (eco2Sum >= 0) {
+        dWalletUsd += sent;
+      } else {
+        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
    *
@@ -43360,81 +44709,84 @@ var ExtendedSVKVesuStateManager = class {
    * 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.
+   */
+  /**
+   * @param skipAvnuDepositSwap Omit AVNU before Vesu multiply when LTV cases already ran this cycle
+   *   (matrix tests expect deposit routes without that step).
    */
-  _classifyDeposits(withdrawAmount) {
+  _classifyDeposits(withdrawAmount, skipAvnuDepositSwap = false) {
     if (withdrawAmount.toNumber() > CASE_THRESHOLD_USD) return [];
     const distributableAmount = this._computeDistributableAmount(
-      this._budget.vesuPerPoolDebtDeltasToBorrow,
+      this._budget.vesuDebtDeltas,
       withdrawAmount
     );
     if (distributableAmount.toNumber() <= CASE_THRESHOLD_USD) return [];
     const { vesuAllocationUsd, extendedAllocationUsd } = 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 = [];
-    let needsWait = false;
-    if (extendedDepositDelta.toNumber() > CASE_THRESHOLD_USD) {
-      let rem = extendedDepositDelta.toNumber();
-      if (rem > CASE_THRESHOLD_USD) {
-        const { remaining } = this._getWalletToEXTENDEDRoute(rem, routes, false);
-        if (remaining < rem) needsWait = true;
-        rem = remaining;
-      }
-      if (rem > CASE_THRESHOLD_USD) {
-        const { remaining } = this._getVAToEXTENDEDRoute(rem, routes, false);
-        if (remaining < rem) needsWait = true;
-        rem = remaining;
-      }
-      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;
-        }
+    if (isExtendedToVesu) {
+      if (dExtUpnl < 0) {
+        this._getUpnlRoute(Math.abs(dExtUpnl), routes);
       }
-    }
-    if (vesuDepositAmount.toNumber() > CASE_THRESHOLD_USD) {
-      const vaShortfall = vesuDepositAmount.toNumber() - this._budget.vaUsd;
-      if (vaShortfall > CASE_THRESHOLD_USD) {
-        let rem = vaShortfall;
-        if (rem > CASE_THRESHOLD_USD && this._budget.walletUsd > CASE_THRESHOLD_USD) {
-          const { remaining } = this._getWalletToVARoute(Math.min(this._budget.walletUsd, rem), routes);
-          rem = remaining;
-        }
-        const isWithdrawalEnough = rem <= this._budget.extAvailWithdraw;
-        if (!isWithdrawalEnough && rem > CASE_THRESHOLD_USD) {
-          const { remaining: upnlRem } = this._getUpnlRoute(rem, routes);
-          rem = upnlRem;
-        }
-        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;
-        }
+      if (dExtUpnl < 0 || dExtAvlWithdraw < 0) {
+        const netAmount = (dExtAvlWithdraw < 0 ? Math.abs(dExtAvlWithdraw) : 0) + (dExtUpnl < 0 ? Math.abs(dExtUpnl) : 0);
+        const walletUsd = this._budget.walletUsd;
+        this._getExtendedToWalletRoute(netAmount, routes);
+        this._getWALLETToVARoute(netAmount + walletUsd, routes);
+      }
+    } else {
+      let netDVaUsd = dVaUsd;
+      if (dWalletUsd < 0) {
+        this._getWalletToVARoute(this._budget.walletUsd, routes);
+        netDVaUsd += dWalletUsd;
+      }
+      if (dVesuBorrowCapacity < 0) {
+        this._buildVesuBorrowRoutes(Math.abs(dVesuBorrowCapacity), routes);
+        netDVaUsd += dVesuBorrowCapacity;
+      }
+      if (netDVaUsd < 0) {
+        this._getVAToEXTENDEDRoute(Math.abs(netDVaUsd), routes, true);
       }
-    }
-    if (needsWait) {
-      routes.push({ type: "RETURN_TO_WAIT" /* RETURN_TO_WAIT */, priority: routes.length });
     }
     for (const vesuDelta of vesuDeltas) {
-      if (vesuDepositAmount.toNumber() > CASE_THRESHOLD_USD) {
+      if (!skipAvnuDepositSwap && vesuDepositAmount.toNumber() > CASE_THRESHOLD_USD) {
+        routes.push({
+          type: "AVNU_DEPOSIT_SWAP" /* 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);
+        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: "VESU_MULTIPLY_INCREASE_LEVER" /* VESU_MULTIPLY_INCREASE_LEVER */,
           priority: routes.length,
@@ -43443,7 +44795,7 @@ var ExtendedSVKVesuStateManager = class {
           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
         });
       }
@@ -43566,8 +44918,13 @@ var ExtendedSVKVesuStateManager = class {
    */
   _buildImbalanceExtExcessShortNoFundsRoutes(exposureDiffBtc) {
     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));
+    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: "EXTENDED_DECREASE_LEVER" /* EXTENDED_DECREASE_LEVER */,
       amount: decDelta,
@@ -43633,13 +44990,15 @@ var ExtendedSVKVesuStateManager = class {
   _classifyCases(withdrawAmount) {
     this._budget.initBudget();
     const withdrawalCases = this._classifyWithdrawal(withdrawAmount);
-    const ltvVesuCases = this._classifyLtvVesu();
-    const ltvExtendedCases = this._classifyLtvExtended();
-    const depositCases = this._classifyDeposits(withdrawAmount);
+    this._budget.applyBuffer(this._config.limitBalanceBufferFactor);
+    const ltvCases = this._classifyLTV();
+    const depositCases = this._classifyDeposits(
+      withdrawAmount,
+      ltvCases.length > 0
+    );
     return [
       ...withdrawalCases,
-      ...ltvVesuCases,
-      ...ltvExtendedCases,
+      ...ltvCases,
       ...depositCases
     ];
   }
@@ -43647,7 +45006,7 @@ var ExtendedSVKVesuStateManager = class {
   // Private — aggregation helpers
   // ═══════════════════════════════════════════════════════════════════════════
   _totalVesuCollateral() {
-    return this._budget.vesuPoolStates.reduce(
+    return this._budget.vesuPools.reduce(
       (acc, pool) => acc.plus(
         pool.collateralAmount
       ),
@@ -43655,7 +45014,7 @@ var ExtendedSVKVesuStateManager = class {
     );
   }
   _totalVesuCollateralUsd() {
-    return this._budget.vesuPoolStates.reduce(
+    return this._budget.vesuPools.reduce(
       (acc, pool) => acc.plus(
         pool.collateralAmount.multipliedBy(pool.collateralPrice)
       ),
@@ -43663,13 +45022,13 @@ var ExtendedSVKVesuStateManager = class {
     );
   }
   _totalExtendedExposure() {
-    return this._budget.extendedPositions.reduce(
+    return this._budget.extendedPositionsView.reduce(
       (acc, position) => acc.plus(position.size),
       new Web3Number(0, USDC_TOKEN_DECIMALS)
     );
   }
   _totalExtendedExposureUsd() {
-    return this._budget.extendedPositions.reduce(
+    return this._budget.extendedPositionsView.reduce(
       (acc, position) => acc.plus(position.valueUsd),
       new Web3Number(0, USDC_TOKEN_DECIMALS)
     );
@@ -43711,7 +45070,7 @@ var ExtendedSVKVesuStateManager = class {
 };
 
 // src/strategies/vesu-extended-strategy/services/executionService.ts
-import { uint256 as uint25622 } from "starknet";
+import { uint256 as uint25623 } from "starknet";
 
 // src/strategies/vesu-extended-strategy/types/transaction-metadata.ts
 var CycleType = /* @__PURE__ */ ((CycleType2) => {
@@ -43756,11 +45115,10 @@ var _ExecutionService = class _ExecutionService {
     this._tokenSymbols = StarknetCallParser.buildTokenSymbolLookup([
       config.wbtcToken,
       config.usdcToken,
-      config.usdceToken,
-      config.vesuAdapter.config.baseToken,
-      config.vesuAdapter.config.collateral,
-      config.vesuAdapter.config.debt,
-      config.vesuAdapter.config.marginToken,
+      config.vesuMultiplyAdapter.config.baseToken,
+      config.vesuMultiplyAdapter.config.collateral,
+      config.vesuMultiplyAdapter.config.debt,
+      config.vesuMultiplyAdapter.config.marginToken,
       config.vesuModifyPositionAdapter.config.collateral,
       config.vesuModifyPositionAdapter.config.debt,
       ...avnuTokens
@@ -43768,19 +45126,18 @@ var _ExecutionService = class _ExecutionService {
     this._tokenDecimals = StarknetCallParser.buildTokenDecimalsLookup([
       config.wbtcToken,
       config.usdcToken,
-      config.usdceToken,
-      config.vesuAdapter.config.baseToken,
-      config.vesuAdapter.config.collateral,
-      config.vesuAdapter.config.debt,
-      config.vesuAdapter.config.marginToken,
+      config.vesuMultiplyAdapter.config.baseToken,
+      config.vesuMultiplyAdapter.config.collateral,
+      config.vesuMultiplyAdapter.config.debt,
+      config.vesuMultiplyAdapter.config.marginToken,
       config.vesuModifyPositionAdapter.config.collateral,
       config.vesuModifyPositionAdapter.config.debt,
       ...avnuTokens
     ]);
     this._poolNames = StarknetCallParser.buildPoolNameLookup([
       {
-        poolId: config.vesuAdapter.config.poolId.toBigInt(),
-        name: `${config.vesuAdapter.config.collateral.symbol}/${config.vesuAdapter.config.debt.symbol}`
+        poolId: config.vesuMultiplyAdapter.config.poolId.toBigInt(),
+        name: `${config.vesuMultiplyAdapter.config.collateral.symbol}/${config.vesuMultiplyAdapter.config.debt.symbol}`
       },
       {
         poolId: config.vesuModifyPositionAdapter.config.poolId.toBigInt(),
@@ -44183,12 +45540,14 @@ var _ExecutionService = class _ExecutionService {
    *
    * For deposit (USDC→BTC): price = sum(USDC sold) / sum(BTC bought)
    * For withdraw (BTC→USDC): price = sum(USDC bought) / sum(BTC sold)
-   */
+  * @returns no-swap means, logic is fine and explicit no swap is needed
+  */
   _getNetExecutionPrice(isDeposit) {
     const prices = [
       this._config.avnuAdapter.lastSwapPriceInfo,
-      this._config.vesuAdapter.lastSwapPriceInfo
+      this._config.vesuMultiplyAdapter.lastSwapPriceInfo
     ].filter((p) => p !== null);
+    assert(prices.length <= 1, "Only one swap price info is allowed");
     if (prices.length === 0) return null;
     if (isDeposit) {
       const totalUsdc = prices.reduce((s, p) => s + p.fromAmount, 0);
@@ -44203,7 +45562,7 @@ var _ExecutionService = class _ExecutionService {
   /** Clears cached swap price info on all adapters to prevent stale data across cycles. */
   _clearAdapterPriceInfo() {
     this._config.avnuAdapter.lastSwapPriceInfo = null;
-    this._config.vesuAdapter.lastSwapPriceInfo = null;
+    this._config.vesuMultiplyAdapter.lastSwapPriceInfo = null;
   }
   // ═══════════════════════════════════════════════════════════════════════════
   // Public API
@@ -44631,7 +45990,7 @@ var _ExecutionService = class _ExecutionService {
   }
   // ── Transfer routes ─────────────────────────────────────────────────────
   /**
-   * WALLET_TO_EXTENDED: Deposit USDC.e from operator wallet directly to Extended.
+   * WALLET_TO_EXTENDED: Deposit USDC from operator wallet directly to Extended.
    *
    * Builds raw approve + deposit calls (NOT through the manager/merkle system)
    * because the wallet interacts with Extended directly, not via vault allocator.
@@ -44646,13 +46005,13 @@ var _ExecutionService = class _ExecutionService {
       );
       return [];
     }
-    const { usdceToken, extendedAdapter } = this._config;
+    const { usdcToken, extendedAdapter } = this._config;
     const extendedContract = extendedAdapter.config.extendedContract;
     const vaultId = extendedAdapter.config.vaultIdExtended;
-    const salt = Math.floor(Math.random() * 10 ** usdceToken.decimals);
-    const uint256Amount = uint25622.bnToUint256(amount.toWei());
+    const salt = Math.floor(Math.random() * 10 ** usdcToken.decimals);
+    const uint256Amount = uint25623.bnToUint256(amount.toWei());
     const approveCall = {
-      contractAddress: usdceToken.address.address,
+      contractAddress: usdcToken.address.address,
       entrypoint: "approve",
       calldata: [
         extendedContract.address,
@@ -44675,7 +46034,7 @@ var _ExecutionService = class _ExecutionService {
     return [approveCall, depositCall];
   }
   /**
-   * VA_TO_EXTENDED: Deposit USDC.e from vault allocator to Extended.
+   * VA_TO_EXTENDED: Deposit USDC from vault allocator to Extended.
    *
    * Uses the extended adapter's getDepositCall to build ManageCalls,
    * then wraps them in a merkle-verified manage call through the manager contract.
@@ -44690,43 +46049,31 @@ var _ExecutionService = class _ExecutionService {
       );
       return [];
     }
-    const swapCall = await this._buildAdapterManageCall(
-      this._config.usdcToUsdceAdapter,
-      true,
-      { amount }
-    );
     const manageCall = await this._buildAdapterManageCall(
       this._config.extendedAdapter,
       true,
       { amount }
     );
-    return [swapCall, manageCall];
+    return [manageCall];
   }
   /**
-   * WALLET_TO_VA: Transfer USDC.e from operator wallet to vault allocator.
+   * WALLET_TO_VA: Transfer USDC from operator wallet to vault allocator.
    * Caps amount by actual wallet balance.
    */
   async _buildWalletToVACalls(route) {
-    const erc20 = new ERC20(this._config.networkConfig);
-    const { usdceToken, vaultAllocator, walletAddress } = this._config;
     const transferAmount = route.amount;
     if (transferAmount.lessThanOrEqualTo(0)) {
       logger.warn(
-        `${this._tag}::_buildWalletToVACalls no USDC.e in wallet to transfer`
+        `${this._tag}::_buildWalletToVACalls no USDC in wallet to transfer`
       );
       return [];
     }
     const transferCall = await this._buildAdapterManageCall(
-      this._config.usdceTransferAdapter,
+      this._config.usdcTransferAdapter,
       false,
       { amount: transferAmount }
     );
-    const swapCall = await this._buildAdapterManageCall(
-      this._config.usdcToUsdceAdapter,
-      false,
-      { amount: transferAmount }
-    );
-    return [transferCall, swapCall];
+    return [transferCall];
   }
   // ── AVNU swap routes ────────────────────────────────────────────────────
   /**
@@ -44759,12 +46106,12 @@ var _ExecutionService = class _ExecutionService {
    */
   async _buildVesuIncreaseLeverCalls(route) {
     const depositManageCall = await this._buildAdapterManageCall(
-      this._config.vesuAdapter,
+      this._config.vesuMultiplyAdapter,
       true,
       {
         amount: route.marginAmount,
         marginSwap: {
-          marginToken: this._config.vesuAdapter.config.marginToken
+          marginToken: this._config.vesuMultiplyAdapter.config.marginToken
           // todo, must be vault token
         },
         leverSwap: {
@@ -44784,11 +46131,11 @@ var _ExecutionService = class _ExecutionService {
   async _buildVesuDecreaseLeverCalls(route) {
     const collateralAmount = route.marginAmount.abs();
     const withdrawManageCall = await this._buildAdapterManageCall(
-      this._config.vesuAdapter,
+      this._config.vesuMultiplyAdapter,
       false,
       {
         amount: collateralAmount,
-        withdrawSwap: { outputToken: this._config.vesuAdapter.config.marginToken }
+        withdrawSwap: { outputToken: this._config.vesuMultiplyAdapter.config.marginToken }
       }
     );
     return [withdrawManageCall];
@@ -45379,140 +46726,6 @@ _ExecutionService.EXTENDED_EXPOSURE_ROUTES = /* @__PURE__ */ new Set([
 ]);
 var ExecutionService = _ExecutionService;
 
-// src/strategies/universal-adapters/usdc<>usdce-adapter.ts
-import { hash as hash11, uint256 as uint25623 } from "starknet";
-var UsdcToUsdceAdapter = class _UsdcToUsdceAdapter extends BaseAdapter {
-  _approveProofReadableId(usdcToUsdce) {
-    const method = usdcToUsdce ? "swap_to_legacy" : "swap_to_new";
-    return `approve_${method}`;
-  }
-  _swapProofReadableId(usdcToUsdce) {
-    const method = usdcToUsdce ? "swap_to_legacy" : "swap_to_new";
-    const target = usdcToUsdce ? this.config.supportedPositions[0].asset : this.config.supportedPositions[1].asset;
-    return `${method}_${target.symbol}`;
-  }
-  buildSwapLeafConfigs(usdcToUsdce) {
-    const method = usdcToUsdce ? "swap_to_legacy" : "swap_to_new";
-    const target = usdcToUsdce ? this.config.supportedPositions[0].asset : this.config.supportedPositions[1].asset;
-    return [
-      {
-        target: target.address,
-        method: "approve",
-        packedArguments: [AVNU_EXCHANGE_FOR_LEGACY_USDC.toBigInt()],
-        id: this._approveProofReadableId(usdcToUsdce),
-        sanitizer: AVNU_LEGACY_SANITIZER
-      },
-      {
-        target: AVNU_EXCHANGE_FOR_LEGACY_USDC,
-        method,
-        packedArguments: [],
-        id: this._swapProofReadableId(usdcToUsdce),
-        sanitizer: AVNU_LEGACY_SANITIZER
-      }
-    ];
-  }
-  async buildSwapCalls(params, usdcToUsdce) {
-    const approveAmount = uint25623.bnToUint256(params.amount.toWei());
-    const target = usdcToUsdce ? this.config.supportedPositions[0].asset : this.config.supportedPositions[1].asset;
-    const method = usdcToUsdce ? "swap_to_legacy" : "swap_to_new";
-    return [
-      {
-        proofReadableId: this._approveProofReadableId(usdcToUsdce),
-        sanitizer: AVNU_LEGACY_SANITIZER,
-        call: {
-          contractAddress: target.address,
-          selector: hash11.getSelectorFromName("approve"),
-          calldata: [
-            AVNU_EXCHANGE_FOR_LEGACY_USDC.toBigInt(),
-            toBigInt(approveAmount.low.toString()),
-            toBigInt(approveAmount.high.toString())
-          ]
-        }
-      },
-      {
-        proofReadableId: this._swapProofReadableId(usdcToUsdce),
-        sanitizer: AVNU_LEGACY_SANITIZER,
-        call: {
-          contractAddress: AVNU_EXCHANGE_FOR_LEGACY_USDC,
-          selector: hash11.getSelectorFromName(method),
-          calldata: [
-            toBigInt(approveAmount.low.toString()),
-            // amount low
-            toBigInt(approveAmount.high.toString())
-            // amount high
-          ]
-        }
-      }
-    ];
-  }
-  constructor(config) {
-    super(config, _UsdcToUsdceAdapter.name, Protocols.AVNU);
-    this.config = config;
-    assert(this.config.supportedPositions.length === 2, "UsdcToUsdceAdapter must have 2 supported positions");
-    assert(this.config.supportedPositions[0].asset.symbol === "USDC", "UsdcToUsdceAdapter must have USDC as the first supported position");
-    assert(this.config.supportedPositions[1].asset.symbol === "USDC.e", "UsdcToUsdceAdapter must have USDCE as the second supported position");
-  }
-  //abstract means the method has no implementation in this class; instead, child classes must implement it.
-  async getAPY(supportedPosition) {
-    return Promise.resolve({ apy: 0, type: "base" /* BASE */ });
-  }
-  async getPosition(supportedPosition) {
-    const toToken = this.config.supportedPositions[1].asset;
-    if (supportedPosition.asset.symbol != toToken.symbol) {
-      return null;
-    }
-    try {
-      const balance = await new ERC20(this.config.networkConfig).balanceOf(
-        toToken.address,
-        this.config.vaultAllocator.address,
-        toToken.decimals
-      );
-      return { amount: balance, remarks: `USDC.e unused balance (VA)` };
-    } catch (_e) {
-      logger.error(`${_UsdcToUsdceAdapter.name}::getPosition: failed for ${toToken.symbol}`);
-      throw new Error(`${_UsdcToUsdceAdapter.name}: failed to get balance for ${toToken.symbol}`);
-    }
-  }
-  async maxDeposit(amount) {
-    return Promise.resolve({
-      tokenInfo: this.config.baseToken,
-      amount: new Web3Number(0, 0),
-      usdValue: 0,
-      apy: { apy: 0, type: "base" /* BASE */ },
-      protocol: Protocols.AVNU,
-      remarks: ""
-    });
-  }
-  async maxWithdraw() {
-    return Promise.resolve({
-      tokenInfo: this.config.baseToken,
-      amount: new Web3Number(0, 0),
-      usdValue: 0,
-      apy: { apy: 0, type: "base" /* BASE */ },
-      protocol: Protocols.AVNU,
-      remarks: ""
-    });
-  }
-  _getDepositLeaf() {
-    return this.buildSwapLeafConfigs(true);
-  }
-  _getWithdrawLeaf() {
-    return this.buildSwapLeafConfigs(false);
-  }
-  async getDepositCall(params) {
-    const calls = await this.buildSwapCalls(params, true);
-    return calls;
-  }
-  //Swap wbtc to usdc
-  async getWithdrawCall(params) {
-    const calls = await this.buildSwapCalls(params, false);
-    return calls;
-  }
-  async getHealthFactor() {
-    return Promise.resolve(1);
-  }
-};
-
 // src/strategies/vesu-extended-strategy/vesu-extended-strategy.tsx
 import { jsx as jsx6, jsxs as jsxs5 } from "react/jsx-runtime";
 var VesuExtendedMultiplierStrategy = class _VesuExtendedMultiplierStrategy extends SVKStrategy {
@@ -45528,9 +46741,6 @@ var VesuExtendedMultiplierStrategy = class _VesuExtendedMultiplierStrategy exten
     });
     this.wbtcToken = Global.getDefaultTokens().find((token) => token.symbol === "WBTC");
     this.usdcToken = this.metadata.additionalInfo.borrowable_assets[0];
-    this.usdceToken = Global.getDefaultTokens().find(
-      (token) => token.symbol === "USDC.e"
-    );
     this.stateManager = this._initializeStateManager();
   }
   /**
@@ -45554,9 +46764,8 @@ var VesuExtendedMultiplierStrategy = class _VesuExtendedMultiplierStrategy exten
       extendedAdapter: extendedAdapterEntry.adapter,
       vaultAllocator: this.metadata.additionalInfo.vaultAllocator,
       walletAddress: this.metadata.additionalInfo.walletAddress,
-      assetToken: Global.getDefaultTokens().find((token) => token.symbol === "USDC"),
-      // ! TODO change to asset() latest
-      usdceToken: this.usdceToken,
+      assetToken: this.asset(),
+      usdcToken: this.usdcToken,
       collateralToken: this.wbtcToken,
       limitBalanceBufferFactor: LIMIT_BALANCE
     };
@@ -45590,7 +46799,7 @@ var VesuExtendedMultiplierStrategy = class _VesuExtendedMultiplierStrategy exten
     }
     return { collateralPrice, debtPrice };
   }
-  async getVesuAdapter() {
+  async getVesuMultiplyAdapter() {
     const vesuAdapter = this.metadata.additionalInfo.adapters.find(
       (adapter) => adapter.adapter.name === VesuMultiplyAdapter.name
     );
@@ -45612,16 +46821,16 @@ var VesuExtendedMultiplierStrategy = class _VesuExtendedMultiplierStrategy exten
     }
     return vesuModifyPositionAdapter.adapter;
   }
-  async getUsdceTransferAdapter() {
-    const usdceTransferAdapter = this.metadata.additionalInfo.adapters.find(
+  async getUsdcTransferAdapter() {
+    const usdcTransferAdapter = this.metadata.additionalInfo.adapters.find(
       (adapter) => adapter.adapter.name === TokenTransferAdapter.name
     );
-    if (!usdceTransferAdapter) {
+    if (!usdcTransferAdapter) {
       throw new Error(
-        `${this.getTag()} Usdce transfer adapter not configured in metadata.`
+        `${this.getTag()} Usdc transfer adapter not configured in metadata.`
       );
     }
-    return usdceTransferAdapter.adapter;
+    return usdcTransferAdapter.adapter;
   }
   async getAvnuAdapter() {
     const avnuAdapter = this.metadata.additionalInfo.adapters.find(
@@ -45650,17 +46859,6 @@ var VesuExtendedMultiplierStrategy = class _VesuExtendedMultiplierStrategy exten
     }
     return extendedAdapter.adapter;
   }
-  async getUsdcToUsdceAdapter() {
-    const usdcToUsdceAdapter = this.metadata.additionalInfo.adapters.find(
-      (adapter) => adapter.adapter.name === UsdcToUsdceAdapter.name
-    );
-    if (!usdcToUsdceAdapter) {
-      throw new Error(
-        `${this.getTag()} UsdcToUsdce adapter not configured in metadata.`
-      );
-    }
-    return usdcToUsdceAdapter.adapter;
-  }
   /**
    * Creates an ExecutionService wired to this strategy's adapters and config.
    * Use with `stateManager.solve()` to get a SolveResult, then pass it to
@@ -45672,34 +46870,30 @@ var VesuExtendedMultiplierStrategy = class _VesuExtendedMultiplierStrategy exten
    */
   async createExecutionService(opts) {
     const [
-      vesuAdapter,
+      vesuMultiplyAdapter,
       vesuModifyPositionAdapter,
-      usdceTransferAdapter,
       extendedAdapter,
       avnuAdapter,
-      usdcToUsdceAdapter
+      usdcTransferAdapter
     ] = await Promise.all([
-      this.getVesuAdapter(),
+      this.getVesuMultiplyAdapter(),
       this.getVesuModifyPositionAdapter(),
-      this.getUsdceTransferAdapter(),
       this.getExtendedAdapter(),
       this.getAvnuAdapter(),
-      this.getUsdcToUsdceAdapter()
+      this.getUsdcTransferAdapter()
     ]);
     const executionConfig = {
       networkConfig: this.config,
       pricer: this.pricer,
-      vesuAdapter,
+      vesuMultiplyAdapter,
       vesuModifyPositionAdapter,
       extendedAdapter,
       avnuAdapter,
-      usdcToUsdceAdapter,
+      usdcTransferAdapter,
       vaultAllocator: this.metadata.additionalInfo.vaultAllocator,
       walletAddress: this.metadata.additionalInfo.walletAddress,
-      usdceTransferAdapter,
       wbtcToken: this.wbtcToken,
       usdcToken: this.usdcToken,
-      usdceToken: this.usdceToken,
       getMerkleTree: () => this.getMerkleTree(),
       getManageCall: (proofs, manageCalls) => this.getManageCall(proofs, manageCalls),
       getBringLiquidityCall: (params) => this.getBringLiquidityCall(params),
@@ -45720,9 +46914,7 @@ var VesuExtendedMultiplierStrategy = class _VesuExtendedMultiplierStrategy exten
     for (let adapter of this.metadata.additionalInfo.adapters) {
       let positions = await adapter.adapter.getPositions();
       if (positions && positions.length > 0) {
-        const filteredPositions = positions.filter((position) => {
-          return position.tokenInfo.address !== this.usdceToken.address;
-        });
+        const filteredPositions = positions;
         allPositions.push(...filteredPositions);
       }
     }
@@ -45917,34 +47109,22 @@ var VesuExtendedMultiplierStrategy = class _VesuExtendedMultiplierStrategy exten
     };
   }
   /**
-   * Fetches the operator wallet's current holdings for USDC.e, USDC, and WBTC,
+   * Fetches the operator wallet's current holdings for USDC and WBTC,
    * returning each token's balance and USD value.
    */
   async getWalletHoldings() {
-    if (!this.usdceToken || !this.wbtcToken || !this.usdcToken) {
+    if (!this.wbtcToken || !this.usdcToken) {
       return [];
     }
     const walletAddress = this.metadata.additionalInfo.walletAddress;
-    const usdceWalletBalance = await new ERC20(this.config).balanceOf(
-      this.usdceToken.address,
-      walletAddress,
-      this.usdceToken.decimals
-    );
     const usdcWalletBalance = await new ERC20(this.config).balanceOf(
       this.usdcToken.address,
       walletAddress,
       this.usdcToken.decimals
     );
-    const price = await this.pricer.getPrice(this.usdceToken.symbol);
-    const wbtcPrice = await this.pricer.getPrice(this.wbtcToken.symbol);
-    const usdceUsdValue = Number(usdceWalletBalance.toFixed(this.usdceToken.decimals)) * price.price;
+    const price = await this.pricer.getPrice(this.usdcToken.symbol);
     const usdcUsdValue = Number(usdcWalletBalance.toFixed(this.usdcToken.decimals)) * price.price;
     return [
-      {
-        tokenInfo: this.usdceToken,
-        amount: usdceWalletBalance,
-        usdValue: usdceUsdValue
-      },
       {
         tokenInfo: this.usdcToken,
         amount: usdcWalletBalance,
@@ -45961,9 +47141,6 @@ function getLooperSettings3(lstSymbol, underlyingSymbol, vaultSettings, pool1, e
   const usdcToken = Global.getDefaultTokens().find(
     (token) => token.symbol === underlyingSymbol
   );
-  const usdceToken = Global.getDefaultTokens().find(
-    (token) => token.symbol === "USDC.e"
-  );
   const baseAdapterConfig = {
     baseToken: wbtcToken,
     supportedPositions: [
@@ -45984,17 +47161,10 @@ function getLooperSettings3(lstSymbol, underlyingSymbol, vaultSettings, pool1, e
     minimumExtendedPriceDifferenceForSwapOpen,
     maximumExtendedPriceDifferenceForSwapClosing
   });
-  const usdcToUsdceAdapter = new UsdcToUsdceAdapter({
-    ...baseAdapterConfig,
-    supportedPositions: [
-      { asset: usdcToken, isDebt: true },
-      { asset: usdceToken, isDebt: false }
-    ]
-  });
   const extendedAdapter = new ExtendedAdapter({
     ...baseAdapterConfig,
     supportedPositions: [
-      { asset: usdceToken, isDebt: false }
+      { asset: usdcToken, isDebt: false }
     ],
     vaultIdExtended,
     extendedContract: EXTENDED_CONTRACT,
@@ -46040,10 +47210,10 @@ function getLooperSettings3(lstSymbol, underlyingSymbol, vaultSettings, pool1, e
       { asset: usdcToken, isDebt: true }
     ]
   });
-  const usdceTransferAdapter = new TokenTransferAdapter({
+  const usdcTransferAdapter = new TokenTransferAdapter({
     ...baseAdapterConfig,
-    baseToken: usdceToken,
-    supportedPositions: [{ asset: usdceToken, isDebt: false }],
+    baseToken: usdcToken,
+    supportedPositions: [{ asset: usdcToken, isDebt: false }],
     fromAddress: vaultSettings.vaultAllocator,
     toAddress: ContractAddr.from(vaultSettings.walletAddress)
   });
@@ -46056,12 +47226,8 @@ function getLooperSettings3(lstSymbol, underlyingSymbol, vaultSettings, pool1, e
     adapter: vesuModifyPositionAdapter
   });
   vaultSettings.adapters.push({
-    id: `${usdceTransferAdapter.name}_${usdceToken.symbol}`,
-    adapter: usdceTransferAdapter
-  });
-  vaultSettings.adapters.push({
-    id: `${usdcToUsdceAdapter.name}_${usdceToken.symbol}_${usdcToken.symbol}`,
-    adapter: usdcToUsdceAdapter
+    id: `${usdcTransferAdapter.name}_${usdcToken.symbol}`,
+    adapter: usdcTransferAdapter
   });
   vaultSettings.adapters.push({
     id: `${extendedAdapter.name}_${wbtcToken.symbol}`,
@@ -46083,12 +47249,10 @@ function getLooperSettings3(lstSymbol, underlyingSymbol, vaultSettings, pool1, e
   vaultSettings.leafAdapters.push(() => vesuModifyPositionAdapter.getDepositLeaf());
   vaultSettings.leafAdapters.push(() => vesuModifyPositionAdapter.getWithdrawLeaf());
   vaultSettings.leafAdapters.push(() => extendedAdapter.getDepositLeaf());
-  vaultSettings.leafAdapters.push(() => usdcToUsdceAdapter.getDepositLeaf());
-  vaultSettings.leafAdapters.push(() => usdcToUsdceAdapter.getWithdrawLeaf());
   vaultSettings.leafAdapters.push(() => avnuAdapter.getDepositLeaf());
   vaultSettings.leafAdapters.push(() => avnuAdapter.getWithdrawLeaf());
-  vaultSettings.leafAdapters.push(() => usdceTransferAdapter.getDepositLeaf());
-  vaultSettings.leafAdapters.push(() => usdceTransferAdapter.getWithdrawLeaf());
+  vaultSettings.leafAdapters.push(() => usdcTransferAdapter.getDepositLeaf());
+  vaultSettings.leafAdapters.push(() => usdcTransferAdapter.getWithdrawLeaf());
   vaultSettings.leafAdapters.push(
     commonAdapter.getApproveAdapter(
       usdcToken.address,
@@ -46533,11 +47697,13 @@ export {
   BaseAdapter,
   BaseStrategy,
   CASE_ROUTE_TYPES,
+  COLLATERAL_PRECISION,
   CaseCategory,
   CaseId,
   CommonAdapter,
   ContractAddr,
   CycleType,
+  DEFAULT_TROVES_STRATEGIES_API,
   ERC20,
   EXTENDED_CONTRACT,
   EXTENDED_SANITIZER,
@@ -46555,6 +47721,7 @@ export {
   FatalError,
   FlowChartColors,
   Global,
+  HealthFactorMath,
   HyperLSTStrategies,
   ILending,
   Initializable,
@@ -46592,6 +47759,7 @@ export {
   StrategyLiveStatus,
   StrategyTag,
   StrategyType,
+  SvkTrovesAdapter,
   TRANSFER_SANITIZER,
   TimeInForce,
   TokenMarketData,
@@ -46639,6 +47807,7 @@ export {
   createEkuboCLStrategy,
   createHyperLSTStrategy,
   createSenseiStrategy,
+  createSolveBudgetFromRawState,
   createStrategy,
   createUniversalStrategy2 as createUniversalStrategy,
   createVesuRebalanceStrategy2 as createVesuRebalanceStrategy,