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

package/dist/index.browser.global.js

@@ -28676,11 +28676,13 @@ ${r2}}` : "}", l2;
     BaseAdapter: () => BaseAdapter,
     BaseStrategy: () => BaseStrategy,
     CASE_ROUTE_TYPES: () => CASE_ROUTE_TYPES,
+    COLLATERAL_PRECISION: () => COLLATERAL_PRECISION,
     CaseCategory: () => CaseCategory,
     CaseId: () => CaseId,
     CommonAdapter: () => CommonAdapter,
     ContractAddr: () => ContractAddr,
     CycleType: () => CycleType,
+    DEFAULT_TROVES_STRATEGIES_API: () => DEFAULT_TROVES_STRATEGIES_API,
     ERC20: () => ERC20,
     EXTENDED_CONTRACT: () => EXTENDED_CONTRACT,
     EXTENDED_SANITIZER: () => EXTENDED_SANITIZER,
@@ -28698,6 +28700,7 @@ ${r2}}` : "}", l2;
     FatalError: () => FatalError,
     FlowChartColors: () => FlowChartColors,
     Global: () => Global,
+    HealthFactorMath: () => HealthFactorMath,
     HyperLSTStrategies: () => HyperLSTStrategies,
     ILending: () => ILending,
     Initializable: () => Initializable,
@@ -28735,6 +28738,7 @@ ${r2}}` : "}", l2;
     StrategyLiveStatus: () => StrategyLiveStatus,
     StrategyTag: () => StrategyTag,
     StrategyType: () => StrategyType,
+    SvkTrovesAdapter: () => SvkTrovesAdapter,
     TRANSFER_SANITIZER: () => TRANSFER_SANITIZER,
     TimeInForce: () => TimeInForce,
     TokenMarketData: () => TokenMarketData,
@@ -28782,6 +28786,7 @@ ${r2}}` : "}", l2;
     createEkuboCLStrategy: () => createEkuboCLStrategy,
     createHyperLSTStrategy: () => createHyperLSTStrategy,
     createSenseiStrategy: () => createSenseiStrategy,
+    createSolveBudgetFromRawState: () => createSolveBudgetFromRawState,
     createStrategy: () => createStrategy,
     createUniversalStrategy: () => createUniversalStrategy2,
     createVesuRebalanceStrategy: () => createVesuRebalanceStrategy2,
@@ -46609,6 +46614,9 @@ ${JSON.stringify(data, null, 2)}`;
       const bn = new _Web3Number2(weiNumber, decimals).dividedBy(10 ** decimals);
       return new _Web3Number2(bn.toString(), decimals);
     }
+    static fromNumber(number2, decimals) {
+      return new _Web3Number2(number2.toString(), decimals);
+    }
   };
 
   // src/dataTypes/address.ts
@@ -76385,6 +76393,48 @@ ${JSON.stringify(data, null, 2)}`;
   );
   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);
+      logger2.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;
+      logger2.verbose(`HealthFactorMath: Max debt amount on looping denominator: ${denominator}`);
+      const debtAmountUSD = numerator.dividedBy(denominator);
+      logger2.verbose(`HealthFactorMath: Max debt amount on looping debtAmountUSD: ${debtAmountUSD.toNumber()}`);
+      const debtAmount = debtAmountUSD.dividedBy(debtPrice);
+      logger2.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);
+      logger2.verbose(`HealthFactorMath: Max debt amount numerator: ${numerator.toNumber()}, collateralAmount: ${collateralAmount.toNumber()}, collateralPrice: ${collateralPrice}, maxLTV: ${maxLTV}, targetHF: ${targetHF}, debtPrice: ${debtPrice}`);
+      const denominator = targetHF * debtPrice;
+      logger2.verbose(`HealthFactorMath: Max debt amount denominator: ${denominator}, targetHF: ${targetHF}, debtPrice: ${debtPrice}`);
+      const debtAmount = numerator.dividedBy(denominator);
+      logger2.verbose(`HealthFactorMath: Max debt amount: ${debtAmount.toNumber()}, numerator: ${numerator.toNumber()}, denominator: ${denominator}`);
+      return new Web3Number(debtAmount.toString(), debtTokenInfo.decimals);
+    }
+  };
+
   // src/utils/index.ts
   function assert3(condition, message) {
     if (!condition) {
@@ -93771,6 +93821,10 @@ spurious results.`);
     name: "Vault",
     logo: ""
   };
+  var TrovesProtocol = {
+    name: "Troves",
+    logo: "https://app.troves.fi/favicon.ico"
+  };
   var Protocols = {
     NONE: NoneProtocol,
     VESU: VesuProtocol,
@@ -93778,7 +93832,8 @@ spurious results.`);
     EXTENDED: ExtendedProtocol,
     EKUBO: EkuboProtocol,
     AVNU: AvnuProtocol,
-    VAULT: VaultProtocol
+    VAULT: VaultProtocol,
+    TROVES: TrovesProtocol
   };
 
   // src/interfaces/initializable.ts
@@ -121484,48 +121539,6 @@ spurious results.`);
     }
   };
 
-  // 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);
-      logger2.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;
-      logger2.verbose(`HealthFactorMath: Max debt amount on looping denominator: ${denominator}`);
-      const debtAmountUSD = numerator.dividedBy(denominator);
-      logger2.verbose(`HealthFactorMath: Max debt amount on looping debtAmountUSD: ${debtAmountUSD.toNumber()}`);
-      const debtAmount = debtAmountUSD.dividedBy(debtPrice);
-      logger2.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);
-      logger2.verbose(`HealthFactorMath: Max debt amount numerator: ${numerator.toNumber()}, collateralAmount: ${collateralAmount.toNumber()}, collateralPrice: ${collateralPrice}, maxLTV: ${maxLTV}, targetHF: ${targetHF}, debtPrice: ${debtPrice}`);
-      const denominator = targetHF * debtPrice;
-      logger2.verbose(`HealthFactorMath: Max debt amount denominator: ${denominator}, targetHF: ${targetHF}, debtPrice: ${debtPrice}`);
-      const debtAmount = numerator.dividedBy(denominator);
-      logger2.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);
@@ -122168,6 +122181,7 @@ spurious results.`);
       const collateralToken = this.config.collateral;
       const debtToken = this.config.debt;
       const { contract: multiplyContract } = this._getMultiplyContract();
+      this.lastSwapPriceInfo = null;
       const {
         existingCollateralInfo,
         existingDebtInfo,
@@ -122204,9 +122218,15 @@ spurious results.`);
       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;
+        assert3(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,
@@ -122222,6 +122242,11 @@ spurious results.`);
           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(
@@ -122245,10 +122270,6 @@ spurious results.`);
       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,
@@ -122272,17 +122293,9 @@ spurious results.`);
             ).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
-            };
-            logger2.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,
@@ -122300,6 +122313,19 @@ spurious results.`);
           );
         }
       }
+      if (executedSwapCount > 0) {
+        this.lastSwapPriceInfo = {
+          source: "ekubo",
+          fromTokenSymbol: aggregatedFromSymbol ?? debtToken.symbol,
+          toTokenSymbol: aggregatedToSymbol,
+          fromAmount: aggregatedFromAmount,
+          toAmount: aggregatedToAmount,
+          effectivePrice: aggregatedToAmount !== 0 ? aggregatedFromAmount / aggregatedToAmount : 0
+        };
+        logger2.verbose(
+          `${_VesuMultiplyAdapter.name}::_getIncreaseCalldata stored aggregated price info: ${aggregatedFromAmount} ${this.lastSwapPriceInfo.fromTokenSymbol} \u2192 ${aggregatedToAmount} ${aggregatedToSymbol}, effectivePrice=${this.lastSwapPriceInfo.effectivePrice}, swaps=${executedSwapCount}`
+        );
+      }
       logger2.verbose(
         `${_VesuMultiplyAdapter.name}::_getIncreaseCalldata leverSwapLimitAmount: ${leverSwapLimitAmount.toWei()}`
       );
@@ -122332,10 +122358,21 @@ spurious results.`);
         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
@@ -122344,6 +122381,9 @@ spurious results.`);
       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,
@@ -122362,6 +122402,9 @@ spurious results.`);
           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(
@@ -122383,17 +122426,9 @@ spurious results.`);
             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
-          };
-          logger2.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,
@@ -122416,6 +122451,7 @@ spurious results.`);
       );
       const withdrawSwapWeights = [];
       if (params.outputToken && !params.outputToken.address.eq(collateralToken.address)) {
+        assert3(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)) {
@@ -122432,12 +122468,34 @@ spurious results.`);
             );
             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
+        };
+        logger2.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;
+      }
       logger2.debug(
         `${_VesuMultiplyAdapter.name}::_buildDecreaseLikeCalldata leverSwapCount=${leverSwap.length}, withdrawSwapCount=${withdrawSwap.length}, withdrawSwapLimitAmount=${withdrawSwapLimitAmount.toNumber()}, subMargin=${params.subMargin.toNumber()}`
       );
@@ -123240,13 +123298,13 @@ spurious results.`);
       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) {
@@ -123315,7 +123373,7 @@ spurious results.`);
     _getDepositLeaf() {
       return [
         {
-          target: this.usdceToken.address,
+          target: this.usdcToken.address,
           method: "approve",
           packedArguments: [this.config.extendedContract.toBigInt()],
           id: this._depositApproveProofReadableId(),
@@ -123335,14 +123393,14 @@ spurious results.`);
     }
     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 = uint256_exports.bnToUint256(params.amount.toWei());
         return [
           {
             proofReadableId: this._depositApproveProofReadableId(),
             sanitizer: SIMPLE_SANITIZER,
             call: {
-              contractAddress: this.usdceToken.address,
+              contractAddress: this.usdcToken.address,
               selector: hash_exports.getSelectorFromName("approve"),
               calldata: [
                 this.config.extendedContract.toBigInt(),
@@ -125922,6 +125980,269 @@ spurious results.`);
     }
   ];
 
+  // 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 n2 = Number.parseFloat(raw);
+      if (Number.isFinite(n2)) {
+        return n2;
+      }
+    }
+    return 0;
+  }
+  var SvkTrovesAdapter = class _SvkTrovesAdapter extends BaseAdapter {
+    constructor(config3) {
+      super(config3, _SvkTrovesAdapter.name, Protocols.TROVES);
+      this.config = config3;
+    }
+    /** 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) {
+          logger2.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) {
+          logger2.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 result2 = { apy, type: "base" /* BASE */ };
+        this.setCache(CACHE_KEY, result2, 3e5);
+        return result2;
+      } catch (error2) {
+        logger2.error(`${_SvkTrovesAdapter.name}::getAPY:`, error2);
+        throw error2;
+      }
+    }
+    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 Contract({
+          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 = uint256_exports.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) {
+          logger2.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 result2 = {
+          amount: total,
+          remarks
+        };
+        this.setCache(CACHE_KEY, result2, 6e4);
+        return result2;
+      } catch (error2) {
+        logger2.error(`${_SvkTrovesAdapter.name}::getPosition:`, error2);
+        throw error2;
+      }
+    }
+    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((config3) => {
+        const { target, method, packedArguments, sanitizer, id: id2 } = config3;
+        return this.constructSimpleLeafData({ id: id2, target, method, packedArguments }, sanitizer);
+      });
+      return { leaves, callConstructor: this.getDepositCall.bind(this) };
+    }
+    getWithdrawAdapter() {
+      const leafConfigs = this._getWithdrawLeaf();
+      const leaves = leafConfigs.map((config3) => {
+        const { target, method, packedArguments, sanitizer, id: id2 } = config3;
+        return this.constructSimpleLeafData({ id: id2, 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 = uint256_exports.bnToUint256(amount.toWei());
+      const receiver = this.config.vaultAllocator;
+      return [
+        {
+          proofReadableId: this._depositApproveProofReadableId(),
+          sanitizer: SIMPLE_SANITIZER,
+          call: {
+            contractAddress: baseToken.address,
+            selector: hash_exports.getSelectorFromName("approve"),
+            calldata: [
+              strategyVault.toBigInt(),
+              toBigInt3(uint256Amount.low.toString()),
+              toBigInt3(uint256Amount.high.toString())
+            ]
+          }
+        },
+        {
+          proofReadableId: this._depositCallProofReadableId(),
+          sanitizer: SIMPLE_SANITIZER,
+          call: {
+            contractAddress: strategyVault,
+            selector: hash_exports.getSelectorFromName("deposit"),
+            calldata: [
+              toBigInt3(uint256Amount.low.toString()),
+              toBigInt3(uint256Amount.high.toString()),
+              receiver.toBigInt()
+            ]
+          }
+        }
+      ];
+    }
+    async getWithdrawCall(params) {
+      const strategyVault = this.config.strategyVault;
+      const amount = params.amount;
+      const uint256Amount = uint256_exports.bnToUint256(amount.toWei());
+      const recv = this.config.vaultAllocator;
+      const owner = this.config.vaultAllocator;
+      return [
+        {
+          proofReadableId: this._withdrawCallProofReadableId(),
+          sanitizer: SIMPLE_SANITIZER,
+          call: {
+            contractAddress: strategyVault,
+            selector: hash_exports.getSelectorFromName("withdraw"),
+            calldata: [
+              toBigInt3(uint256Amount.low.toString()),
+              toBigInt3(uint256Amount.high.toString()),
+              recv.toBigInt(),
+              owner.toBigInt()
+            ]
+          }
+        }
+      ];
+    }
+    getHealthFactor() {
+      return Promise.resolve(10);
+    }
+  };
+
   // src/data/vault-manager.abi.json
   var vault_manager_abi_default = [
     {
@@ -128881,6 +129202,249 @@ spurious results.`);
     getStrategySettings("mRe7YIELD", "mRe7YIELD", hypermRe7YIELD, false, false)
   ];
 
+  // src/strategies/vesu-extended-strategy/services/ltv-imbalance-rebalance-math.ts
+  function ceilBtc(v, precision) {
+    const f2 = 10 ** precision;
+    return Math.ceil(v * f2) / f2;
+  }
+  function floorBtc(v, precision) {
+    const f2 = 10 ** precision;
+    return Math.floor(v * f2) / f2;
+  }
+  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, b2) {
+    return {
+      dExtPosition: a.dExtPosition + b2.dExtPosition,
+      dVesuPosition: a.dVesuPosition + b2.dVesuPosition,
+      dVesuDebt: a.dVesuDebt + b2.dVesuDebt,
+      dExtAvlWithdraw: a.dExtAvlWithdraw + b2.dExtAvlWithdraw,
+      dExtUpnl: a.dExtUpnl + b2.dExtUpnl,
+      dVaUsd: a.dVaUsd + b2.dVaUsd,
+      dWalletUsd: a.dWalletUsd + b2.dWalletUsd,
+      dVesuBorrowCapacity: a.dVesuBorrowCapacity + b2.dVesuBorrowCapacity,
+      dTransferVesuToExt: a.dTransferVesuToExt + b2.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, sign2) {
+    d.dVaUsd += sign2 * (draws.vaUsd ?? 0);
+    d.dWalletUsd += sign2 * (draws.walletUsd ?? 0);
+    d.dVesuBorrowCapacity += sign2 * (draws.vesuBorrowCapacity ?? 0);
+    d.dExtAvlWithdraw += sign2 * (draws.extAvlWithdraw ?? 0);
+    d.dExtUpnl += sign2 * (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, config3) {
+    const extResult = fixExtMargin(ext, price, pool);
+    const vesuResult = fixVesuMargin(vesu, price, pool, config3.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: config3 } = inputs;
+    const pool = { ...inputs.funding };
+    const p1 = phase1(ext, vesu, btcPrice, pool, config3);
+    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,
+      config3.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";
@@ -128912,6 +129476,7 @@ spurious results.`);
     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";
@@ -128936,19 +129501,56 @@ spurious results.`);
     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 */]: [],
@@ -128971,6 +129573,17 @@ spurious results.`);
     ["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 */,
@@ -129193,199 +129806,590 @@ spurious results.`);
   }
   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 = (b2) => ({
+        token: b2.token,
+        amount: new Web3Number(b2.amount.toFixed(b2.token.decimals), b2.token.decimals),
+        usdValue: b2.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();
       assert3(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();
+      assert3(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((b2) => ({
+          token: b2.token.symbol,
+          amount: b2.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((b2) => `${b2.token}=${b2.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, b2) => a + b2.toNumber(), 0);
-      let totalUnusedUsd = this.unusedBalance.reduce((a, b2) => a + b2.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;
-        logger2.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;
-        logger2.debug(`SolveBudget::initBudget pendingDeposit=${pendingDeposit} -> increased walletUsd by ${inTransit}`);
+        if (this.walletBalance) {
+          this._addUsdToTokenBalance(this.walletBalance, inTransit);
+        }
+        logger2.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() {
+      assert3(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;
-    }
-    get extPendingDeposit() {
-      return this._extPendingDeposit;
-    }
-    // ── 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;
-      logger2.debug(`SolveBudget::spendVA used=${used}, vaUsd=${this._vaUsd}, totalUnused=${this._totalUnused}`);
-      return used;
+      const debtSum = this.vesuPerPoolDebtDeltasToBorrow.reduce((a, b2) => a + b2.toNumber(), 0);
+      let u = this.unusedBalance.reduce((a, b2) => a + this.bufferedTokenUsd(b2), 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, b2) => a + this.bufferedTokenUsd(b2), 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
+      );
     }
-    addToVA(amount) {
-      assert3(amount >= 0, "SolveBudget::addToVA amount must be positive");
-      this._vaUsd += amount;
-      this._totalUnused += amount;
-      logger2.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;
-      logger2.debug(`SolveBudget::spendWallet used=${used}, walletUsd=${this._walletUsd}, totalUnused=${this._totalUnused}`);
-      return used;
+    /** 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)
+      );
     }
-    addToWallet(amount) {
-      assert3(amount >= 0, "SolveBudget::addToWallet amount must be positive");
-      this._walletUsd += amount;
-      this._totalUnused += amount;
-      logger2.debug(`SolveBudget::addToWallet amount=${amount}, walletUsd=${this._walletUsd}, totalUnused=${this._totalUnused}`);
+    /**
+     * Rebuilds {@link unusedBalance} from vault + wallet snapshots (same merge as refresh).
+     */
+    _recomputeUnusedBalance() {
+      const balanceMap = /* @__PURE__ */ new Map();
+      const merge2 = (b2) => {
+        if (!b2) return;
+        const key = b2.token.address.toString();
+        const row = {
+          token: b2.token,
+          amount: new Web3Number(b2.amount.toFixed(b2.token.decimals), b2.token.decimals),
+          usdValue: b2.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);
+        }
+      };
+      merge2(this.vaultAssetBalance);
+      merge2(this.vaultUsdcBalance);
+      merge2(this.walletBalance);
+      this.unusedBalance = Array.from(balanceMap.values());
     }
-    spendVAWallet(desired) {
-      let remaining = Math.max(0, desired);
+    // ── Spend methods (return amount consumed, auto-decrement totalUnused) ─
+    /**
+     * 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();
+      logger2.debug(`SolveBudget::spendVA usedRaw=${usedRaw}, vaUsd=${this.vaUsd}, totalUnused=${this.totalUnused}`);
+      return usedRaw;
+    }
+    /**
+     * 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();
+      logger2.debug(`SolveBudget::spendVaRawUsd usedRaw=${usedRaw}, vaUsd=${this.vaUsd}, totalUnused=${this.totalUnused}`);
+      return usedRaw;
+    }
+    /**
+     * Add **raw nominal USD** to VA (borrow proceeds, wallet→VA in raw USDC, etc.).
+     */
+    addToVA(rawUsd) {
+      assert3(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();
+      logger2.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();
+      logger2.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) {
+      assert3(rawUsd >= 0, "SolveBudget::addToWallet amount must be positive");
+      if (rawUsd === 0) return;
+      if (this.walletBalance) {
+        this._addUsdToTokenBalance(this.walletBalance, rawUsd);
+      }
+      this._recomputeUnusedBalance();
+      logger2.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;
-      assert3(amount > 0, "SolveBudget::_updateExtAvailWithdraw amount must be positive");
+    _updateExtAvailWithdraw(desiredRaw, isSpend) {
+      assert3(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);
       }
-      logger2.debug(`SolveBudget::updateExtAvailWithdraw amount=${amount}, extAvailWithdraw=${this._extAvailWithdraw}, totalUnused=${this._totalUnused}`);
-      return amount;
+      logger2.debug(`SolveBudget::updateExtAvailWithdraw rawDelta=${rawDelta}, extAvailWithdraw=${this.extAvailWithdraw}, totalUnused=${this.totalUnused}`);
+      return rawDelta;
     }
-    _updateExtAvailUpnl(desired, isSpend) {
-      let amount = desired;
-      assert3(amount > 0, "SolveBudget::_updateExtAvailUpnl amount must be positive");
+    _updateExtAvailUpnl(desiredRaw, isSpend) {
+      assert3(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);
-      }
-      logger2.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);
-      logger2.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);
+      }
+      logger2.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);
+      logger2.debug(`SolveBudget::updateExtAvailTrade rawSum=${used + usedUpnl}, extAvailTrade=${this.extAvailTrade}, totalUnused=${this.totalUnused}`);
+      return used + usedUpnl;
+    }
+    // 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);
+      }
+      logger2.debug(`SolveBudget::updateExtAvailTrade rawSum=${used + usedUpnl}, extAvailTrade=${this.extAvailTrade}, totalUnused=${this.totalUnused}`);
       return used + usedUpnl;
     }
-    spendExtAvailUpnl(desired) {
-      return this._updateExtAvailUpnl(desired, true);
+    spendExtAvailWithdraw(rawDesired) {
+      return this._updateExtAvailWithdraw(rawDesired, true);
     }
-    addToExtAvailTrade(amount) {
-      this._updateExtAvailWithdraw(amount, false);
-      logger2.debug(`SolveBudget::addToExtAvailTrade amount=${amount}, extAvailTrade=${this._extAvailTrade}, totalUnused=${this._totalUnused}`);
+    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);
+    }
+    /**
+     * 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) {
+      assert3(rawUsd >= 0, "SolveBudget::addToExtAvailTrade amount must be non-negative");
+      if (rawUsd <= CASE_THRESHOLD_USD) return;
+      if (!this.extendedBalance) {
+        logger2.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 b2 = this.extendedBalance.balance.toNumber();
+        const e = this.extendedBalance.equity.toNumber();
+        this.extendedBalance.balance = safeUsdcWeb3Number(b2 + toMargin);
+        this.extendedBalance.equity = safeUsdcWeb3Number(e + toMargin);
+        logger2.debug(
+          `SolveBudget::addToExtAvailTrade margin-first rawUsd=${toMargin} (shortfallBefore=${shortfall}, balance=${b2 + toMargin}, equity=${e + toMargin})`
+        );
+      }
+      if (toLiquid > CASE_THRESHOLD_USD) {
+        this._updateExtAvailWithdraw(toLiquid, false);
+      }
+      logger2.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];
@@ -129396,13 +130400,12 @@ spurious results.`);
         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 });
       }
-      logger2.debug(`SolveBudget::spendVesuBorrowCapacity used=${used}, vesuBorrowCapacity=${this._vesuBorrowCapacity}, totalUnused=${this._totalUnused}`);
+      logger2.debug(`SolveBudget::spendVesuBorrowCapacity used=${used}, vesuBorrowCapacity=${this.vesuBorrowCapacity}, totalUnused=${this.totalUnused}`);
       return { used, spendsByPool };
     }
     repayVesuBorrowCapacity(desired) {
       assert3(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];
@@ -129412,7 +130415,7 @@ spurious results.`);
         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 });
       }
-      logger2.debug(`SolveBudget::repayVesuBorrowCapacity used=${used}, vesuBorrowCapacity=${this._vesuBorrowCapacity}, totalUnused=${this._totalUnused}`);
+      logger2.debug(`SolveBudget::repayVesuBorrowCapacity used=${used}, vesuBorrowCapacity=${this.vesuBorrowCapacity}, totalUnused=${this.totalUnused}`);
       return { used, spendsByPool };
     }
     // ── State mutation ──────────────────────────────────────────────────
@@ -129434,13 +130437,21 @@ spurious results.`);
       pool.debtUsdValue = pool.debtAmount.toNumber() * pool.debtPrice;
       const vesuPerPoolDebtDeltasToBorrow = this._computeperPoolDebtDeltasToBorrow();
       this.vesuPerPoolDebtDeltasToBorrow = vesuPerPoolDebtDeltasToBorrow.map((item) => item.deltaDebt);
-      const sum = this.vesuPerPoolDebtDeltasToBorrow.reduce((a, b2) => a.plus(b2), 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) {
@@ -129451,6 +130462,56 @@ spurious results.`);
           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 b2 = this.extendedBalance.balance.toNumber();
+        const e = this.extendedBalance.equity.toNumber();
+        this.extendedBalance.balance = safeUsdcWeb3Number(b2 - rem);
+        this.extendedBalance.equity = safeUsdcWeb3Number(e - rem);
       }
     }
     /**
@@ -129478,6 +130539,23 @@ spurious results.`);
       return output2;
     }
   };
+  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(config3) {
       this._tag = "ExtendedSVKVesuStateManager";
@@ -129513,7 +130591,7 @@ spurious results.`);
         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(result2);
       return result2;
@@ -129528,30 +130606,44 @@ spurious results.`);
     async _refresh() {
       logger2.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()
       ]);
-      logger2.verbose(`_refresh vaultAllocatorBalance: ${vaultAllocatorBalance.usdValue}, walletBalance: ${walletBalance.usdValue}`);
+      logger2.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(
@@ -129563,10 +130655,14 @@ spurious results.`);
       );
     }
     // 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,
@@ -129578,20 +130674,38 @@ spurious results.`);
       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) {
@@ -129610,30 +130724,29 @@ spurious results.`);
       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
       };
     }
     /**
@@ -129751,12 +130864,12 @@ spurious results.`);
      * 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}]`
@@ -129776,7 +130889,7 @@ spurious results.`);
       }
     }
     _validateVesuPoolPricesOrThrow() {
-      for (const pool of this._budget.vesuPoolStates) {
+      for (const pool of this._budget.vesuPools) {
         const poolLabel = pool.poolId.shortString();
         this._assertPositiveFinite(
           pool.collateralPrice,
@@ -129789,8 +130902,8 @@ spurious results.`);
       }
     }
     _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()}`
@@ -129829,18 +130942,26 @@ spurious results.`);
       );
     }
     /**
-     * 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, b2) => acc + b2.usdValue,
-        0
-      );
+      const totalUnusedUsd = this._budget.unusedBalancesBufferedUsdSum;
       logger2.debug(
-        `${this._tag}::_computeTotalInvestableAmount unusedBalances=${JSON.stringify(this._budget.unusedBalance.map((b2) => ({ token: b2.token.symbol, amount: b2.amount.toNumber(), usdValue: b2.usdValue })))}`
+        `${this._tag}::_computeTotalInvestableAmount unusedBalances=${JSON.stringify(this._budget.unusedBalanceRows.map((b2) => ({ token: b2.token.symbol, amount: b2.amount.toNumber(), usdValue: b2.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);
       logger2.verbose(`_computeTotalInvestableAmount totalUnusedUsd: ${totalUnusedUsd}, extendedAvailable: ${extendedAvailable.toNumber()}`);
       return new Web3Number(totalUnusedUsd.toFixed(USDC_TOKEN_DECIMALS), USDC_TOKEN_DECIMALS).plus(extendedAvailable);
     }
@@ -129871,7 +130992,7 @@ spurious results.`);
       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();
@@ -129883,8 +131004,6 @@ spurious results.`);
         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) {
@@ -129903,14 +131022,17 @@ spurious results.`);
      * 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,
@@ -129920,12 +131042,12 @@ spurious results.`);
           _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
@@ -129938,7 +131060,7 @@ spurious results.`);
      * 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(
@@ -129975,8 +131097,8 @@ spurious results.`);
      */
     _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];
         logger2.debug(
           `${this._tag}::_computeTargetExtendedExposure poolId=${pool.poolId.toString()}, collateralAmount=${pool.collateralAmount.toNumber()}, collateralDelta=${delta.collateralDelta.toNumber()}`
@@ -129994,7 +131116,7 @@ spurious results.`);
       );
     }
     _hasNoExtendedPositions() {
-      return this._budget.extendedPositions.length === 0;
+      return this._budget.extendedPositionsView.length === 0;
     }
     /**
      * Creates a single-element delta array for the default instrument
@@ -130005,7 +131127,7 @@ spurious results.`);
         {
           instrument: this._config.extendedAdapter.config.extendedMarketName,
           delta: new Web3Number(
-            delta.toFixed(COLLATERAL_PRECISION),
+            delta.toFixedRoundDown(COLLATERAL_PRECISION),
             USDC_TOKEN_DECIMALS
           )
         }
@@ -130017,7 +131139,7 @@ spurious results.`);
      */
     _distributeExposureDeltaAcrossPositions(totalDelta) {
       const totalExposure = this._totalExtendedExposure();
-      return this._budget.extendedPositions.map((position) => {
+      return this._budget.extendedPositionsView.map((position) => {
         const share = this._positionExposureShareFraction(
           position,
           totalExposure
@@ -130025,7 +131147,7 @@ spurious results.`);
         return {
           instrument: position.instrument,
           delta: new Web3Number(
-            totalDelta.multipliedBy(share).toFixed(COLLATERAL_PRECISION),
+            totalDelta.multipliedBy(share).toFixedRoundDown(COLLATERAL_PRECISION),
             USDC_TOKEN_DECIMALS
           )
         };
@@ -130037,7 +131159,7 @@ spurious results.`);
      * 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();
     }
@@ -130049,7 +131171,10 @@ spurious results.`);
      * 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
@@ -130057,8 +131182,8 @@ spurious results.`);
     }
     _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));
@@ -130103,13 +131228,17 @@ spurious results.`);
       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 });
       }
@@ -130165,9 +131294,9 @@ spurious results.`);
     //     });
     // }
     _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);
@@ -130176,9 +131305,9 @@ spurious results.`);
       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) {
@@ -130189,9 +131318,9 @@ spurious results.`);
       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);
@@ -130204,40 +131333,42 @@ spurious results.`);
     }
     _getExtendedToWalletRoute(tryAmount, routes, shouldAddWaitRoute = true) {
       if (tryAmount <= CASE_THRESHOLD_USD) return { routes, remaining: tryAmount };
-      assert3(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);
-      assert3(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);
+      assert3(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.
@@ -130252,7 +131383,7 @@ spurious results.`);
       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) {
@@ -130275,48 +131406,90 @@ spurious results.`);
         totalExtUsed = usableWithrawAmount + upnlUsed;
       }
       if (remaining > CASE_THRESHOLD_USD) {
-        const avgCollPrice = this._budget.vesuPoolStates[0]?.collateralPrice ?? 1;
-        assert3(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;
+        assert3(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 = (n2) => Number(n2.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) {
@@ -130349,56 +131522,231 @@ spurious results.`);
      *
      * Design: accumulate all ext-to-wallet moves, add transfer routes at the end (principle #3).
      */
-    _classifyLtvVesu() {
-      const debtDeltaSum = this._budget.vesuPerPoolDebtDeltasToBorrow.reduce(
-        (a, b2) => a + b2.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() {
+      assert3(this._budget.vesuPools.length === 1, `${this._tag}::_classifyLTV expects exactly one Vesu pool`);
+      const d = rebalance(this._ltvRebalanceInputsFromBudget());
+      if (this._isLtvRebalanceNoop(d)) return [];
+      logger2.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}`
       );
-      logger2.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:
@@ -130475,60 +131823,7 @@ spurious results.`);
     //   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:
@@ -130595,6 +131890,62 @@ spurious results.`);
     //   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
      *
@@ -130609,81 +131960,84 @@ spurious results.`);
      * 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)
-     */
-    _classifyDeposits(withdrawAmount) {
+     * 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, 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 (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 (needsWait) {
-        routes.push({ type: "RETURN_TO_WAIT" /* RETURN_TO_WAIT */, priority: routes.length });
+      if (isExtendedToVesu) {
+        if (dExtUpnl < 0) {
+          this._getUpnlRoute(Math.abs(dExtUpnl), routes);
+        }
+        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);
+        }
       }
       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,
@@ -130692,7 +132046,7 @@ spurious results.`);
             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
           });
         }
@@ -130815,8 +132169,13 @@ spurious results.`);
      */
     _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,
@@ -130882,13 +132241,15 @@ spurious results.`);
     _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
       ];
     }
@@ -130896,7 +132257,7 @@ spurious results.`);
     // Private — aggregation helpers
     // ═══════════════════════════════════════════════════════════════════════════
     _totalVesuCollateral() {
-      return this._budget.vesuPoolStates.reduce(
+      return this._budget.vesuPools.reduce(
         (acc, pool) => acc.plus(
           pool.collateralAmount
         ),
@@ -130904,7 +132265,7 @@ spurious results.`);
       );
     }
     _totalVesuCollateralUsd() {
-      return this._budget.vesuPoolStates.reduce(
+      return this._budget.vesuPools.reduce(
         (acc, pool) => acc.plus(
           pool.collateralAmount.multipliedBy(pool.collateralPrice)
         ),
@@ -130912,13 +132273,13 @@ spurious results.`);
       );
     }
     _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)
       );
@@ -131002,11 +132363,10 @@ spurious results.`);
       this._tokenSymbols = StarknetCallParser.buildTokenSymbolLookup([
         config3.wbtcToken,
         config3.usdcToken,
-        config3.usdceToken,
-        config3.vesuAdapter.config.baseToken,
-        config3.vesuAdapter.config.collateral,
-        config3.vesuAdapter.config.debt,
-        config3.vesuAdapter.config.marginToken,
+        config3.vesuMultiplyAdapter.config.baseToken,
+        config3.vesuMultiplyAdapter.config.collateral,
+        config3.vesuMultiplyAdapter.config.debt,
+        config3.vesuMultiplyAdapter.config.marginToken,
         config3.vesuModifyPositionAdapter.config.collateral,
         config3.vesuModifyPositionAdapter.config.debt,
         ...avnuTokens
@@ -131014,19 +132374,18 @@ spurious results.`);
       this._tokenDecimals = StarknetCallParser.buildTokenDecimalsLookup([
         config3.wbtcToken,
         config3.usdcToken,
-        config3.usdceToken,
-        config3.vesuAdapter.config.baseToken,
-        config3.vesuAdapter.config.collateral,
-        config3.vesuAdapter.config.debt,
-        config3.vesuAdapter.config.marginToken,
+        config3.vesuMultiplyAdapter.config.baseToken,
+        config3.vesuMultiplyAdapter.config.collateral,
+        config3.vesuMultiplyAdapter.config.debt,
+        config3.vesuMultiplyAdapter.config.marginToken,
         config3.vesuModifyPositionAdapter.config.collateral,
         config3.vesuModifyPositionAdapter.config.debt,
         ...avnuTokens
       ]);
       this._poolNames = StarknetCallParser.buildPoolNameLookup([
         {
-          poolId: config3.vesuAdapter.config.poolId.toBigInt(),
-          name: `${config3.vesuAdapter.config.collateral.symbol}/${config3.vesuAdapter.config.debt.symbol}`
+          poolId: config3.vesuMultiplyAdapter.config.poolId.toBigInt(),
+          name: `${config3.vesuMultiplyAdapter.config.collateral.symbol}/${config3.vesuMultiplyAdapter.config.debt.symbol}`
         },
         {
           poolId: config3.vesuModifyPositionAdapter.config.poolId.toBigInt(),
@@ -131429,12 +132788,14 @@ spurious results.`);
      *
      * 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);
+      assert3(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);
@@ -131449,7 +132810,7 @@ spurious results.`);
     /** 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
@@ -131877,7 +133238,7 @@ spurious results.`);
     }
     // ── 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.
@@ -131892,13 +133253,13 @@ spurious results.`);
         );
         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 salt = Math.floor(Math.random() * 10 ** usdcToken.decimals);
       const uint256Amount = uint256_exports.bnToUint256(amount.toWei());
       const approveCall = {
-        contractAddress: usdceToken.address.address,
+        contractAddress: usdcToken.address.address,
         entrypoint: "approve",
         calldata: [
           extendedContract.address,
@@ -131921,7 +133282,7 @@ spurious results.`);
       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.
@@ -131936,43 +133297,31 @@ spurious results.`);
         );
         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)) {
         logger2.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 ────────────────────────────────────────────────────
     /**
@@ -132005,12 +133354,12 @@ spurious results.`);
      */
     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: {
@@ -132030,11 +133379,11 @@ spurious results.`);
     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];
@@ -132625,139 +133974,6 @@ spurious results.`);
   ]);
   var ExecutionService = _ExecutionService;
 
-  // src/strategies/universal-adapters/usdc<>usdce-adapter.ts
-  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 = uint256_exports.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: hash_exports.getSelectorFromName("approve"),
-            calldata: [
-              AVNU_EXCHANGE_FOR_LEGACY_USDC.toBigInt(),
-              toBigInt3(approveAmount.low.toString()),
-              toBigInt3(approveAmount.high.toString())
-            ]
-          }
-        },
-        {
-          proofReadableId: this._swapProofReadableId(usdcToUsdce),
-          sanitizer: AVNU_LEGACY_SANITIZER,
-          call: {
-            contractAddress: AVNU_EXCHANGE_FOR_LEGACY_USDC,
-            selector: hash_exports.getSelectorFromName(method),
-            calldata: [
-              toBigInt3(approveAmount.low.toString()),
-              // amount low
-              toBigInt3(approveAmount.high.toString())
-              // amount high
-            ]
-          }
-        }
-      ];
-    }
-    constructor(config3) {
-      super(config3, _UsdcToUsdceAdapter.name, Protocols.AVNU);
-      this.config = config3;
-      assert3(this.config.supportedPositions.length === 2, "UsdcToUsdceAdapter must have 2 supported positions");
-      assert3(this.config.supportedPositions[0].asset.symbol === "USDC", "UsdcToUsdceAdapter must have USDC as the first supported position");
-      assert3(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) {
-        logger2.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
   var import_jsx_runtime6 = __toESM(require_jsx_runtime());
   var VesuExtendedMultiplierStrategy = class _VesuExtendedMultiplierStrategy extends SVKStrategy {
@@ -132773,9 +133989,6 @@ spurious results.`);
       });
       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();
     }
     /**
@@ -132799,9 +134012,8 @@ spurious results.`);
         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
       };
@@ -132835,7 +134047,7 @@ spurious results.`);
       }
       return { collateralPrice, debtPrice };
     }
-    async getVesuAdapter() {
+    async getVesuMultiplyAdapter() {
       const vesuAdapter = this.metadata.additionalInfo.adapters.find(
         (adapter2) => adapter2.adapter.name === VesuMultiplyAdapter.name
       );
@@ -132857,16 +134069,16 @@ spurious results.`);
       }
       return vesuModifyPositionAdapter.adapter;
     }
-    async getUsdceTransferAdapter() {
-      const usdceTransferAdapter = this.metadata.additionalInfo.adapters.find(
+    async getUsdcTransferAdapter() {
+      const usdcTransferAdapter = this.metadata.additionalInfo.adapters.find(
         (adapter2) => adapter2.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(
@@ -132895,17 +134107,6 @@ spurious results.`);
       }
       return extendedAdapter.adapter;
     }
-    async getUsdcToUsdceAdapter() {
-      const usdcToUsdceAdapter = this.metadata.additionalInfo.adapters.find(
-        (adapter2) => adapter2.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
@@ -132917,34 +134118,30 @@ spurious results.`);
      */
     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),
@@ -132965,9 +134162,7 @@ spurious results.`);
       for (let adapter2 of this.metadata.additionalInfo.adapters) {
         let positions = await adapter2.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);
         }
       }
@@ -133162,34 +134357,22 @@ spurious results.`);
       };
     }
     /**
-     * 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,
@@ -133206,9 +134389,6 @@ spurious results.`);
     const usdcToken = Global.getDefaultTokens().find(
       (token) => token.symbol === underlyingSymbol
     );
-    const usdceToken = Global.getDefaultTokens().find(
-      (token) => token.symbol === "USDC.e"
-    );
     const baseAdapterConfig = {
       baseToken: wbtcToken,
       supportedPositions: [
@@ -133229,17 +134409,10 @@ spurious results.`);
       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,
@@ -133285,10 +134458,10 @@ spurious results.`);
         { 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)
     });
@@ -133301,12 +134474,8 @@ spurious results.`);
       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}`,
@@ -133328,12 +134497,10 @@ spurious results.`);
     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,