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

package/dist/index.js

@@ -6215,7 +6215,7 @@ var EkuboQuoter = class _EkuboQuoter {
   async _callQuoterApi(fromToken, toToken, amount, retry = 0) {
     try {
       const url = this.ENDPOINT.replace("{{AMOUNT}}", amount.toWei()).replace("{{TOKEN_FROM_ADDRESS}}", fromToken).replace("{{TOKEN_TO_ADDRESS}}", toToken);
-      logger.verbose(`EkuboQuoter::_callQuoterApi url: ${url}`);
+      logger.info(`EkuboQuoter::_callQuoterApi url: ${url}`);
       const quote = await import_axios6.default.get(url);
       return quote.data;
     } catch (error) {
@@ -8085,6 +8085,7 @@ var vesu_rebalance_abi_default = [
 var CacheClass = class {
   constructor() {
     this.cache = /* @__PURE__ */ new Map();
+    this.isCacheEnabled = true;
   }
   setCache(key, data, ttl = 6e4) {
     const timestamp = Date.now();
@@ -8092,7 +8093,7 @@ var CacheClass = class {
   }
   getCache(key) {
     const cachedData = this.cache.get(key);
-    if (!cachedData || !this.isCacheValid(key)) {
+    if (!cachedData || !this.isCacheValid(key) || !this.isCacheEnabled) {
       return null;
     }
     return cachedData.data;
@@ -8103,6 +8104,12 @@ var CacheClass = class {
     const { timestamp, ttl } = cachedData;
     return Date.now() - timestamp <= ttl;
   }
+  disableCache() {
+    this.isCacheEnabled = false;
+  }
+  enableCache() {
+    this.isCacheEnabled = true;
+  }
 };
 
 // src/strategies/base-strategy.ts
@@ -28889,7 +28896,7 @@ var VesuAdapter = class _VesuAdapter extends CacheClass {
       throw new Error("LTV is 0");
     }
     this.setCache(CACHE_KEY, ltv, 3e5);
-    return this.getCache(CACHE_KEY);
+    return ltv;
   }
   async getPositions(config, blockNumber = "latest") {
     if (!this.pricer) {
@@ -28973,6 +28980,9 @@ var VesuAdapter = class _VesuAdapter extends CacheClass {
       debtPrice = (await pricer.getPrice(this.config.debt.priceProxySymbol || this.config.debt.symbol)).price;
     }
     logger.verbose(`VesuAdapter::getAssetPrices collateralPrice: ${collateralPrice}, debtPrice: ${debtPrice}`);
+    if (isNaN(collateralPrice) || isNaN(debtPrice) || collateralPrice == 0 || debtPrice == 0) {
+      throw new Error(`VesuAdapter::getAssetPrices collateralPrice: ${collateralPrice}, debtPrice: ${debtPrice}`);
+    }
     return {
       collateralTokenAmount,
       collateralUSDAmount,
@@ -34611,20 +34621,23 @@ var VesuMultiplyAdapter = class _VesuMultiplyAdapter extends BaseAdapter {
   }
   _buildZeroAmountSwapsWithWeights(quote, token, reverseRoutes = false) {
     const swaps = quote.splits.map((split) => {
-      const routeNodes = split.route.map((_route) => ({
-        pool_key: {
-          token0: ContractAddr.from(_route.pool_key.token0),
-          token1: ContractAddr.from(_route.pool_key.token1),
-          fee: _route.pool_key.fee,
-          tick_spacing: _route.pool_key.tick_spacing.toString(),
-          extension: _route.pool_key.extension
-        },
-        sqrt_ratio_limit: Web3Number.fromWei(_route.sqrt_ratio_limit, 18),
-        skip_ahead: Web3Number.fromWei(_route.skip_ahead, 0)
-      }));
-      if (reverseRoutes) {
-        routeNodes.reverse();
-      }
+      let sellToken = token.address;
+      const routeNodes = split.route.map((_route) => {
+        let isSellToken0 = sellToken.eqString(_route.pool_key.token0);
+        isSellToken0 = reverseRoutes ? !isSellToken0 : isSellToken0;
+        sellToken = isSellToken0 ? ContractAddr.from(_route.pool_key.token1) : ContractAddr.from(_route.pool_key.token0);
+        return {
+          pool_key: {
+            token0: ContractAddr.from(_route.pool_key.token0),
+            token1: ContractAddr.from(_route.pool_key.token1),
+            fee: _route.pool_key.fee,
+            tick_spacing: _route.pool_key.tick_spacing.toString(),
+            extension: _route.pool_key.extension
+          },
+          sqrt_ratio_limit: isSellToken0 ? Web3Number.fromWei(MIN_SQRT_RATIO_LIMIT.toString(), 18) : Web3Number.fromWei(MAX_SQRT_RATIO_LIMIT.toString(), 18),
+          skip_ahead: Web3Number.fromWei(_route.skip_ahead, 0)
+        };
+      });
       return {
         route: routeNodes,
         token_amount: {
@@ -34946,6 +34959,7 @@ var VesuMultiplyAdapter = class _VesuMultiplyAdapter extends BaseAdapter {
         collateralToken.address.address,
         requiredAmount
       );
+      logger.info(`VesuMultiplyAdapter::_getIncreaseCalldata requiredAmount: ${requiredAmount}`);
       if (marginSwapQuote.price_impact > 0.01) {
         throw new Error(
           `VesuMultiplyAdapter: Margin swap price impact too high (${marginSwapQuote.price_impact})`
@@ -34972,7 +34986,7 @@ var VesuMultiplyAdapter = class _VesuMultiplyAdapter extends BaseAdapter {
       legLTV,
       dexPrice
     );
-    logger.verbose(
+    logger.info(
       `${_VesuMultiplyAdapter.name}::_getIncreaseCalldata debtAmount: ${debtAmount}, addedCollateral: ${addedCollateral}`
     );
     let leverSwap = [];
@@ -34990,8 +35004,10 @@ var VesuMultiplyAdapter = class _VesuMultiplyAdapter extends BaseAdapter {
             collateralToken.address.address,
             params.leverSwap?.exactOutput?.abs()
           );
+          logger.info(`VesuMultiplyAdapter::_getIncreaseCalldata amount: ${params.leverSwap?.exactOutput?.abs()}`);
           debtAmount = Web3Number.fromWei(swapQuote.total_calculated, debtToken.decimals).abs();
         }
+        logger.info(`VesuMultiplyAdapter::_getIncreaseCalldata debtAmount: ${debtAmount}`);
         swapQuote = await ekuboQuoter.getQuoteExactInput(
           debtToken.address.address,
           collateralToken.address.address,
@@ -35018,7 +35034,7 @@ var VesuMultiplyAdapter = class _VesuMultiplyAdapter extends BaseAdapter {
           await new Promise((resolve) => setTimeout(resolve, 1e4));
         } else {
           throw new Error(
-            `VesuMultiplyAdapter: Price impact too high (${swapQuote.price_impact}), skipping swap`
+            `VesuMultiplyAdapter: Price impact too high (${swapQuote.price_impact}), skipping swap, debtAmount=${debtAmount.toNumber()}, collateralPrice=${collateralPrice}, debtPrice=${debtPrice}`
           );
         }
       } catch (error) {
@@ -36003,6 +36019,9 @@ var VesuModifyPositionAdapter = class _VesuModifyPositionAdapter extends BaseAda
 // src/strategies/universal-adapters/extended-adapter.ts
 var import_starknet27 = require("starknet");
 
+// src/modules/ExtendedWrapperSDk/wrapper.ts
+var import_bignumber6 = __toESM(require("bignumber.js"));
+
 // src/modules/ExtendedWrapperSDk/types.ts
 var OrderSide = /* @__PURE__ */ ((OrderSide2) => {
   OrderSide2["BUY"] = "BUY";
@@ -36087,8 +36106,60 @@ var AssetOperationStatus = /* @__PURE__ */ ((AssetOperationStatus3) => {
 })(AssetOperationStatus || {});
 
 // src/modules/ExtendedWrapperSDk/wrapper.ts
+function asRecord(v) {
+  return v !== null && typeof v === "object" && !Array.isArray(v) ? v : null;
+}
+function pickTradingConfig(row) {
+  const tc = row.trading_config ?? row.tradingConfig;
+  return asRecord(tc);
+}
+function readTcString(tc, snake, camel) {
+  const v = tc[snake] ?? tc[camel];
+  if (v === void 0 || v === null) return void 0;
+  return String(v).trim();
+}
+function tradingRulesFromMarketRow(marketName, row) {
+  const r = asRecord(row);
+  if (!r) {
+    throw new Error(`ExtendedWrapper: invalid market payload for ${marketName}`);
+  }
+  const tc = pickTradingConfig(r);
+  if (!tc) {
+    throw new Error(`ExtendedWrapper: missing tradingConfig for market ${marketName}`);
+  }
+  const minS = readTcString(tc, "min_order_size", "minOrderSize");
+  const qtyStep = readTcString(tc, "min_order_size_change", "minOrderSizeChange");
+  const pxStep = readTcString(tc, "min_price_change", "minPriceChange");
+  if (!minS || !qtyStep || !pxStep) {
+    throw new Error(`ExtendedWrapper: incomplete tradingConfig for market ${marketName}`);
+  }
+  const minOrderSize = new import_bignumber6.default(minS);
+  const qty = new import_bignumber6.default(qtyStep);
+  const px = new import_bignumber6.default(pxStep);
+  if (!minOrderSize.isFinite() || minOrderSize.lte(0)) {
+    throw new Error(`ExtendedWrapper: invalid minOrderSize for ${marketName}`);
+  }
+  if (!qty.isFinite() || qty.lte(0)) {
+    throw new Error(`ExtendedWrapper: invalid minOrderSizeChange for ${marketName}`);
+  }
+  if (!px.isFinite() || px.lte(0)) {
+    throw new Error(`ExtendedWrapper: invalid minPriceChange for ${marketName}`);
+  }
+  return { minOrderSize, qtyStep: qty, priceStep: px };
+}
+function roundToStepBn(value, step) {
+  if (step.lte(0)) return value;
+  return value.div(step).round(0, import_bignumber6.default.ROUND_HALF_UP).times(step);
+}
+function formatBnForApi(bn, step) {
+  const dp = Math.max(step.decimalPlaces() ?? 0, bn.decimalPlaces() ?? 0, 0);
+  return Number(bn.toFixed(Math.min(80, dp))).toString();
+}
 var ExtendedWrapper = class {
   constructor(config) {
+    /** Per-market rules from GET /markets (tradingConfig); retained for process lifetime (no TTL). */
+    this.marketTradingRulesCache = /* @__PURE__ */ new Map();
+    this.marketTradingRulesInflight = /* @__PURE__ */ new Map();
     this.apiKey = config.apiKey;
     this.timeout = config.timeout || 3e4;
     this.retries = config.retries || 3;
@@ -36152,13 +36223,75 @@ var ExtendedWrapper = class {
     }
     throw lastError || new Error("Request failed after all retries");
   }
+  async resolveTradingRules(marketName) {
+    const cached = this.marketTradingRulesCache.get(marketName);
+    if (cached) return cached;
+    const existing = this.marketTradingRulesInflight.get(marketName);
+    if (existing) return existing;
+    const inflight = (async () => {
+      const res = await this.getMarkets(marketName);
+      if (res.status !== "OK") {
+        throw new Error(
+          `ExtendedWrapper: getMarkets failed for ${marketName}: ${res.message}`
+        );
+      }
+      const rows = res.data;
+      if (!Array.isArray(rows) || rows.length === 0) {
+        throw new Error(
+          `ExtendedWrapper: empty markets response for ${marketName}`
+        );
+      }
+      const row = rows.find((m) => asRecord(m)?.name === marketName);
+      if (!row) {
+        throw new Error(
+          `ExtendedWrapper: market ${marketName} not found in markets list`
+        );
+      }
+      const rules = tradingRulesFromMarketRow(marketName, row);
+      this.marketTradingRulesCache.set(marketName, rules);
+      return rules;
+    })();
+    this.marketTradingRulesInflight.set(marketName, inflight);
+    void inflight.finally(() => {
+      if (this.marketTradingRulesInflight.get(marketName) === inflight) {
+        this.marketTradingRulesInflight.delete(marketName);
+      }
+    });
+    return inflight;
+  }
   /**
    * Create a new order on Extended Exchange
    */
   async createOrder(request) {
+    const rules = await this.resolveTradingRules(request.market_name);
+    const amountBn = new import_bignumber6.default(String(request.amount).trim());
+    const priceBn = new import_bignumber6.default(String(request.price).trim());
+    if (!amountBn.isFinite() || amountBn.lte(0)) {
+      throw new Error(`ExtendedWrapper: invalid order amount=${request.amount}`);
+    }
+    if (!priceBn.isFinite() || priceBn.lte(0)) {
+      throw new Error(`ExtendedWrapper: invalid order price=${request.price}`);
+    }
+    if (amountBn.lt(rules.minOrderSize)) {
+      throw new Error(
+        `ExtendedWrapper: order amount ${request.amount} is below minOrderSize ${rules.minOrderSize.toFixed()} for ${request.market_name}`
+      );
+    }
+    const adjAmount = roundToStepBn(amountBn, rules.qtyStep);
+    const adjPrice = roundToStepBn(priceBn, rules.priceStep);
+    if (adjAmount.lt(rules.minOrderSize)) {
+      throw new Error(
+        `ExtendedWrapper: amount after tick rounding ${formatBnForApi(adjAmount, rules.qtyStep)} is below minOrderSize ${rules.minOrderSize.toFixed()} (${request.market_name})`
+      );
+    }
+    const payload = {
+      ...request,
+      amount: formatBnForApi(adjAmount, rules.qtyStep),
+      price: formatBnForApi(adjPrice, rules.priceStep)
+    };
     return this.makeRequest("/api/v1/orders", false, {
       method: "POST",
-      body: JSON.stringify(request)
+      body: JSON.stringify(payload)
     });
   }
   /**
@@ -36768,14 +36901,6 @@ var ExtendedAdapter = class _ExtendedAdapter extends BaseAdapter {
         logger.error("error initializing client");
         return null;
       }
-      const setLeverage = await this.setLeverage(
-        leverage,
-        this.config.extendedMarketName
-      );
-      if (!setLeverage) {
-        logger.error("error depositing or setting leverage");
-        return null;
-      }
       const { ask, bid } = await this.fetchOrderBookFromExtended();
       if (!ask || !bid || ask.lessThanOrEqualTo(0) || bid.lessThanOrEqualTo(0)) {
         logger.error(
@@ -36915,13 +37040,13 @@ var ExtendedAdapter = class _ExtendedAdapter extends BaseAdapter {
   async createExtendedPositon(client, marketName, amount, price, side) {
     try {
       const result = side === "SELL" /* SELL */ ? await client.createSellOrder(marketName, amount, price, {
-        postOnly: false,
-        reduceOnly: false,
-        timeInForce: "IOC" /* IOC */
+        post_only: false,
+        reduce_only: false,
+        time_in_force: "IOC" /* IOC */
       }) : await client.createBuyOrder(marketName, amount, price, {
-        postOnly: false,
-        reduceOnly: true,
-        timeInForce: "IOC" /* IOC */
+        post_only: false,
+        reduce_only: true,
+        time_in_force: "IOC" /* IOC */
       });
       if (result.data.id) {
         const position_id = result.data.id.toString();
@@ -42386,20 +42511,42 @@ function mergeDeltas(a, b) {
     dTransferVesuToExt: a.dTransferVesuToExt + b.dTransferVesuToExt
   };
 }
-function drawFunds(need, keys, pool) {
+function routableDrawAmount(avail, need, minRoutable) {
+  if (avail <= 0 || need <= 0) return 0;
+  const raw = Math.min(avail, need);
+  if (raw <= 0) return 0;
+  if (minRoutable <= 0) return raw;
+  return raw > minRoutable ? raw : 0;
+}
+function drawFunds(need, keys, pool, minRoutable) {
   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);
+    const take = routableDrawAmount(avail, unmet, minRoutable);
+    if (take <= 0) continue;
     draws[k] = take;
     pool[k] -= take;
     unmet -= take;
   }
   return { draws, filled: need - unmet, unmet };
 }
+function drawExtendedAggregated(need, pool, minRoutable) {
+  const draws = {};
+  if (need <= 0) return { draws, filled: 0, unmet: 0 };
+  const totalCap = Math.max(0, pool.extAvlWithdraw) + Math.max(0, pool.extUpnl);
+  const want = routableDrawAmount(totalCap, need, minRoutable);
+  if (want <= 0) return { draws, filled: 0, unmet: need };
+  const fromAvl = Math.min(Math.max(0, pool.extAvlWithdraw), want);
+  pool.extAvlWithdraw -= fromAvl;
+  const fromUpnl = Math.min(Math.max(0, pool.extUpnl), want - fromAvl);
+  pool.extUpnl -= fromUpnl;
+  if (fromAvl > 0) draws.extAvlWithdraw = fromAvl;
+  if (fromUpnl > 0) draws.extUpnl = fromUpnl;
+  const filled = fromAvl + fromUpnl;
+  return { draws, filled, unmet: need - filled };
+}
 function sumKeys(draws, keys) {
   return keys.reduce((s, k) => s + (draws[k] ?? 0), 0);
 }
@@ -42410,33 +42557,39 @@ function applyDrawsToDeltas(d, draws, sign) {
   d.dExtAvlWithdraw += sign * (draws.extAvlWithdraw ?? 0);
   d.dExtUpnl += sign * (draws.extUpnl ?? 0);
 }
-function fixExtMargin(ext, price, pool) {
+function fixExtMargin(ext, price, pool, config) {
   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);
+  const minR = config.minRoutableUsd ?? 0;
+  const { draws, filled, unmet } = drawFunds(deficit, ["walletUsd", "vaUsd", "vesuBorrowCapacity"], pool, minR);
   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) {
+function fixVesuMargin(vesu, price, pool, hfBuffer, config) {
   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);
+  const minR = config.minRoutableUsd ?? 0;
+  const rMain = drawFunds(repayUsd, ["vaUsd", "walletUsd"], pool, minR);
+  applyDrawsToDeltas(d, rMain.draws, -1);
+  const rExt = drawExtendedAggregated(rMain.unmet, pool, minR);
+  applyDrawsToDeltas(d, rExt.draws, -1);
+  const filled = rMain.filled + rExt.filled;
+  const unmet = rExt.unmet;
   d.dVesuDebt -= filled / vesu.debtPrice;
-  const fromExt = sumKeys(draws, ["extAvlWithdraw", "extUpnl"]);
+  const fromExt = sumKeys(rExt.draws, ["extAvlWithdraw", "extUpnl"]);
   if (fromExt > 0) d.dTransferVesuToExt -= fromExt;
   return { d, unmet };
 }
 function phase1(ext, vesu, price, pool, config) {
-  const extResult = fixExtMargin(ext, price, pool);
-  const vesuResult = fixVesuMargin(vesu, price, pool, config.hfBuffer);
+  const extResult = fixExtMargin(ext, price, pool, config);
+  const vesuResult = fixVesuMargin(vesu, price, pool, config.hfBuffer, config);
   return {
     deltas: mergeDeltas(extResult.d, vesuResult.d),
     extDeficitRemaining: extResult.unmet,
@@ -42476,26 +42629,31 @@ function roundFinalPosition(extPos, vesuPos, rawF, precision) {
   }
   return Math.max(0, Math.min(fFromExt, fFromVesu));
 }
-function phase2(extPos, vesuPos, extEquity, vesuDebt, vesu, extLev, price, pool, precision) {
+function phase2(extPos, vesuPos, extEquity, vesuDebt, vesu, extLev, price, pool, config) {
   const d = emptyDeltas();
+  const precision = config.positionPrecision;
+  const minR = config.minRoutableUsd ?? 0;
   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 rMain = drawFunds(equityCostUsd, ["vaUsd", "walletUsd"], pool, minR);
+      applyDrawsToDeltas(d, rMain.draws, -1);
+      const rExt = drawExtendedAggregated(rMain.unmet, pool, minR);
+      applyDrawsToDeltas(d, rExt.draws, -1);
+      const filled = rMain.filled + rExt.filled;
       const grownBtc = computeVesuGrowthFromEquity(filled, vesu, price);
       d.dVesuPosition += grownBtc;
       fundedGrowthBtc = grownBtc;
       d.dVesuDebt += computeVesuGrowthDebt(grownBtc, vesu, price);
-      const fromExt = sumKeys(draws, ["extAvlWithdraw", "extUpnl"]);
+      const fromExt = sumKeys(rExt.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);
+      const { draws, filled } = drawFunds(marginCostUsd, ["walletUsd", "vaUsd", "vesuBorrowCapacity"], pool, minR);
       applyDrawsToDeltas(d, draws, -1);
       const grownBtc = filled * extLev / price;
       d.dExtPosition += grownBtc;
@@ -42536,6 +42694,7 @@ function phase2(extPos, vesuPos, extEquity, vesuDebt, vesu, extLev, price, pool,
   return d;
 }
 function rebalance(inputs) {
+  logger.info(`ltv-imbalance-rebalance-math::rebalance inputs=${JSON.stringify(inputs)}`);
   const { ext, vesu, btcPrice, config } = inputs;
   const pool = { ...inputs.funding };
   const p1 = phase1(ext, vesu, btcPrice, pool, config);
@@ -42552,7 +42711,7 @@ function rebalance(inputs) {
     ext.leverage,
     btcPrice,
     pool,
-    config.positionPrecision
+    config
   );
   return mergeDeltas(p1.deltas, p2);
 }
@@ -43133,15 +43292,15 @@ var SolveBudget = class {
     return this.vesuPoolStates[0];
   }
   // ── Derived getters (buffered where applicable) ─────────────────────
-  /** Buffered VA USD: strategy-asset slot + optional USDC slot. */
+  /** Buffered VA USD: non-stable asset slot (if any) + USDC slot. */
   get vaUsd() {
-    return this.bufferedTokenUsd(this.vaultAssetBalance) + this.bufferedTokenUsd(this.vaultUsdcBalance);
+    return 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). */
+  /** Buffered USD in VA USDC bucket (includes full VA idle when asset === USDC). */
   get vaUsdcUsd() {
     return this.bufferedTokenUsd(this.vaultUsdcBalance);
   }
@@ -43223,9 +43382,13 @@ var SolveBudget = class {
   get vesuRebalanceFlags() {
     return this.shouldVesuRebalance;
   }
-  /** Raw USD in VA (USDC slot + asset slot); spend caps when executing transfers. */
+  /** Raw USD in VA (USDC slot + non-stable asset slot when distinct); spend caps when executing transfers. */
   _vaRawUsd() {
-    return this._rawTokenUsd(this.vaultUsdcBalance) + this._rawTokenUsd(this.vaultAssetBalance);
+    return this._rawTokenUsd(this.vaultUsdcBalance);
+  }
+  /** VA liquidity usable for repay / {@link spendVaRawUsd} (matches nominal balances after any {@link applyBuffer} scaling). */
+  get vaRawUsd() {
+    return this._vaRawUsd();
   }
   _walletRawUsd() {
     return this._rawTokenUsd(this.walletBalance);
@@ -43301,7 +43464,7 @@ var SolveBudget = class {
       rem -= fromUsdc;
     }
     if (rem > 0 && this.vaultAssetBalance) {
-      this._deductUsdFromTokenBalance(this.vaultAssetBalance, rem);
+      throw new Error(`Not implemented: spendVA with vaultAssetBalance`);
     }
     this._recomputeUnusedBalance();
     logger.debug(`SolveBudget::spendVA usedRaw=${usedRaw}, vaUsd=${this.vaUsd}, totalUnused=${this.totalUnused}`);
@@ -43311,7 +43474,10 @@ var SolveBudget = class {
    * 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 capRaw = (
+      // this._rawTokenUsd(this.vaultUsdcBalance) + this._rawTokenUsd(this.vaultAssetBalance);
+      this._rawTokenUsd(this.vaultUsdcBalance)
+    );
     const usedRaw = Math.min(capRaw, Math.max(0, rawUsdDesired));
     if (usedRaw <= CASE_THRESHOLD_USD) return 0;
     let rem = usedRaw;
@@ -43321,7 +43487,7 @@ var SolveBudget = class {
       rem -= fromUsdc;
     }
     if (rem > 0 && this.vaultAssetBalance) {
-      this._deductUsdFromTokenBalance(this.vaultAssetBalance, rem);
+      throw new Error(`Not implemented: spendVaRawUsd with vaultAssetBalance`);
     }
     this._recomputeUnusedBalance();
     logger.debug(`SolveBudget::spendVaRawUsd usedRaw=${usedRaw}, vaUsd=${this.vaUsd}, totalUnused=${this.totalUnused}`);
@@ -43336,7 +43502,7 @@ var SolveBudget = class {
     if (this.vaultUsdcBalance) {
       this._addUsdToTokenBalance(this.vaultUsdcBalance, rawUsd);
     } else if (this.vaultAssetBalance) {
-      this._addUsdToTokenBalance(this.vaultAssetBalance, rawUsd);
+      throw new Error(`Not implemented: addToVA with vaultAssetBalance`);
     }
     this._recomputeUnusedBalance();
     logger.debug(`SolveBudget::addToVA rawUsd=${rawUsd}, vaUsd=${this.vaUsd}, totalUnused=${this.totalUnused}`);
@@ -43375,7 +43541,7 @@ var SolveBudget = class {
     if (isSpend) {
       const capRaw = this.extendedBalance?.availableForWithdrawal?.toNumber() ?? 0;
       const useRaw = Math.min(capRaw, desiredRaw);
-      if (useRaw <= CASE_THRESHOLD_USD) return 0;
+      if (useRaw <= 0) return 0;
       rawDelta = -useRaw;
     } else {
       rawDelta = desiredRaw;
@@ -43395,7 +43561,7 @@ var SolveBudget = class {
     if (isSpend) {
       const capRaw = this.extendedBalance?.unrealisedPnl?.toNumber() ?? 0;
       const useRaw = Math.min(capRaw, desiredRaw);
-      if (useRaw <= CASE_THRESHOLD_USD) return 0;
+      if (useRaw <= 0) return 0;
       rawDelta = -useRaw;
     } else {
       rawDelta = desiredRaw;
@@ -43410,10 +43576,12 @@ var SolveBudget = class {
     return rawDelta;
   }
   spendExtAvailTrade(rawDesired) {
-    const used = this._updateExtAvailWithdraw(rawDesired, true);
-    const usedUpnl = this._updateExtAvailUpnl(rawDesired, true);
-    logger.debug(`SolveBudget::updateExtAvailTrade rawSum=${used + usedUpnl}, extAvailTrade=${this.extAvailTrade}, totalUnused=${this.totalUnused}`);
-    return used + usedUpnl;
+    const usedWd = this._updateExtAvailWithdraw(rawDesired, true);
+    const tookWd = Math.abs(usedWd);
+    const rem = rawDesired - tookWd;
+    const usedUpnl = rem > 0 ? this._updateExtAvailUpnl(rem, true) : 0;
+    logger.debug(`SolveBudget::updateExtAvailTrade rawSum=${usedWd + usedUpnl}, extAvailTrade=${this.extAvailTrade}, totalUnused=${this.totalUnused}`);
+    return usedWd + usedUpnl;
   }
   // simply reduces available amounts, but maintains equity and balance.
   spendExtAvailTradeToEquityOnly(rawDesired) {
@@ -43733,7 +43901,7 @@ var ExtendedSVKVesuStateManager = class {
       this._fetchExtendedPositions()
     ]);
     logger.verbose(
-      `${this._tag}::_refresh VA asset ${vaultAssetBalance.token.symbol}=$${vaultAssetBalance.usdValue.toFixed(2)}${vaultUsdcBalance ? `, VA USDC=$${vaultUsdcBalance.usdValue.toFixed(2)}` : ""}, wallet=${walletBalance.usdValue}`
+      `${this._tag}::_refresh ${vaultAssetBalance ? `VA asset ${vaultAssetBalance.token.symbol}=$${vaultAssetBalance.usdValue.toFixed(2)}, ` : ""}VA USDC=${vaultUsdcBalance.usdValue.toFixed(2)}, wallet=${walletBalance.usdValue}`
     );
     const unusedBalance = this._computeUnusedBalances(
       vaultAssetBalance,
@@ -43758,23 +43926,28 @@ var ExtendedSVKVesuStateManager = class {
       },
       vesuPoolStates
     });
+    this._budget.logStateSummary();
     const totalUnusedUsd = unusedBalance.reduce(
       (acc, b) => acc + b.usdValue,
       0
     );
     logger.info(
-      `${this._tag}::_refresh completed \u2014 unusedBalances: ${unusedBalance.length} tokens, totalUnusedUsd: ${totalUnusedUsd.toFixed(2)}, extendedPositions: ${extendedPositions.length}, vesuPools: ${vesuPoolStates.length} - availableForTrade: ${extendedBalance?.availableForTrade.toNumber()} - availableForWithdrawal: ${extendedBalance?.availableForWithdrawal.toNumber()} - unrealisedPnl: ${extendedBalance?.unrealisedPnl.toNumber()} - extendedBalance::balance: ${extendedBalance?.balance.toNumber()} - extendedBalance::pendingDeposit: ${extendedBalance?.pendingDeposit.toNumber()} - extendedBalance::equity: ${extendedBalance?.equity.toNumber()}`
+      `${this._tag}::_refresh completed \u2014 unusedBalances: ${unusedBalance.length} tokens [${unusedBalance.map((b) => `${b.token.symbol}=$${b.usdValue.toFixed(2)}`).join(", ")}], totalUnusedUsd: ${totalUnusedUsd.toFixed(2)}, extendedPositions: ${extendedPositions.length} [${extendedPositions.map((p) => `${p.instrument}=${p.size.toFixed(6)} ${p.side}, ${p.valueUsd.toFixed(6)} ${p.instrument}`).join(", ")}], vesuPools: ${vesuPoolStates.length} [${vesuPoolStates.map((p) => `${p.poolId.shortString()}=${p.debtAmount.toFixed(6)} ${p.debtToken.symbol}, ${p.collateralAmount.toFixed(6)} ${p.collateralToken.symbol}`).join(", ")}], availableForTrade: ${extendedBalance?.availableForTrade.toNumber()} - availableForWithdrawal: ${extendedBalance?.availableForWithdrawal.toNumber()} - unrealisedPnl: ${extendedBalance?.unrealisedPnl.toNumber()} - extendedBalance::balance: ${extendedBalance?.balance.toNumber()} - extendedBalance::pendingDeposit: ${extendedBalance?.pendingDeposit.toNumber()} - extendedBalance::equity: ${extendedBalance?.equity.toNumber()}`
     );
   }
   // todo add communication check with python server of extended. if not working, throw error in solve function.
-  /** True when strategy asset and USDC share one token — VA USDC slot is unused (all in asset balance). */
+  /** True when strategy asset and USDC share one token — VA idle balance is tracked as USDC, not as asset. */
   _vaultAssetAndUsdcAreSameToken() {
     return this._config.assetToken.address.eq(this._config.usdcToken.address);
   }
   /**
-   * Reads the {@link StateManagerConfig.assetToken} balance idle in the vault allocator.
+   * Reads idle {@link StateManagerConfig.assetToken} in the vault allocator when it differs from USDC.
+   * When asset and USDC are the same token, returns null (that balance is reported via {@link _fetchVaultAllocatorUsdcBalanceIfDistinct} only).
    */
   async _fetchVaultAllocatorAssetBalance() {
+    if (this._vaultAssetAndUsdcAreSameToken()) {
+      return null;
+    }
     const { assetToken, vaultAllocator, networkConfig, pricer } = this._config;
     const balance = await new ERC20(networkConfig).balanceOf(
       assetToken.address,
@@ -43786,11 +43959,9 @@ var ExtendedSVKVesuStateManager = class {
     return { token: assetToken, amount: balance, 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).
+   * Reads {@link StateManagerConfig.usdcToken} idle in the vault allocator (always — distinct asset or USDC-as-asset).
    */
   async _fetchVaultAllocatorUsdcBalanceIfDistinct() {
-    if (this._vaultAssetAndUsdcAreSameToken()) return null;
     const { usdcToken, vaultAllocator, networkConfig, pricer } = this._config;
     const balance = await new ERC20(networkConfig).balanceOf(
       usdcToken.address,
@@ -43804,7 +43975,7 @@ var ExtendedSVKVesuStateManager = class {
     return { token: usdcToken, amount: balance, usdValue };
   }
   /**
-   * Merges vault-allocator asset, optional vault-allocator USDC, and operator wallet
+   * Merges vault-allocator asset (if any), vault-allocator USDC, and operator wallet
    * balances into entries keyed by token address.
    */
   _computeUnusedBalances(vaultAssetBalance, vaultUsdcBalance, walletBalance) {
@@ -43816,8 +43987,8 @@ var ExtendedSVKVesuStateManager = class {
         usdValue: tb.usdValue
       });
     };
-    put(vaultAssetBalance);
-    if (vaultUsdcBalance) put(vaultUsdcBalance);
+    if (vaultAssetBalance) put(vaultAssetBalance);
+    put(vaultUsdcBalance);
     const key = walletBalance.token.address.toString();
     const existing = balanceMap.get(key);
     if (existing) {
@@ -44336,7 +44507,10 @@ var ExtendedSVKVesuStateManager = class {
   // ── ExecutionRoute-building helpers ─────────────────────────────────────────────
   // ── Atomic route builders ────────────────────────────────────────────
   _buildVesuRepayRoutes(totalUsd, routes) {
-    const { used, spendsByPool } = this._budget.repayVesuBorrowCapacity(totalUsd);
+    const vaCap = this._budget.vaRawUsd;
+    const repayUsd = Math.min(totalUsd, vaCap);
+    if (repayUsd <= CASE_THRESHOLD_USD) return;
+    const { used, spendsByPool } = this._budget.repayVesuBorrowCapacity(repayUsd);
     for (const route of spendsByPool) {
       routes.push({ type: "VESU_REPAY" /* VESU_REPAY */, ...route, priority: routes.length });
     }
@@ -44430,7 +44604,7 @@ var ExtendedSVKVesuStateManager = class {
     return { routes, remaining: tryAmount };
   }
   _getVAToEXTENDEDRoute(tryAmount, routes, shouldAddWaitRoute = true) {
-    const usable = Math.min(tryAmount, this._budget.vaUsd);
+    const usable = Math.min(tryAmount, this._budget.vaUsdcUsd);
     if (usable > CASE_THRESHOLD_USD) {
       const vaUsed = this._budget.spendVA(usable);
       this._budget.addToExtAvailTrade(vaUsed);
@@ -44445,7 +44619,7 @@ var ExtendedSVKVesuStateManager = class {
   }
   _getExtendedToWalletRoute(tryAmount, routes, shouldAddWaitRoute = true) {
     if (tryAmount <= CASE_THRESHOLD_USD) return { routes, remaining: tryAmount };
-    const rawCap = this._budget.extAvailWithdraw + this._budget.extAvailUpnl;
+    const rawCap = this._budget.extAvailWithdraw + Math.max(0, this._budget.extAvailUpnl);
     const rawSpend = Math.min(tryAmount, rawCap);
     if (rawSpend <= CASE_THRESHOLD_USD) return { routes, remaining: tryAmount };
     const rawOut = this._budget.spendExtAvailTrade(rawSpend);
@@ -44635,7 +44809,9 @@ var ExtendedSVKVesuStateManager = class {
    * Design: accumulate all ext-to-wallet moves, add transfer routes at the end (principle #3).
    */
   /**
-   * Unified LTV classifier. Computes both Vesu repay and Extended margin needs,
+   * Unified LTV / exposure classifier: `rebalance()` drives both LTV (debt, margin,
+   * funding) and Vesu↔Extended position alignment. There is no separate imbalance pass.
+   * Computes both Vesu repay and Extended margin needs,
    * then builds all routes in a single pass with no duplicate transfers.
    *
    * Vesu repay priority: VA > Wallet > ExtAvl > ExtUpnl
@@ -44691,7 +44867,8 @@ var ExtendedSVKVesuStateManager = class {
       },
       config: {
         positionPrecision: COLLATERAL_PRECISION,
-        hfBuffer: 0.05
+        hfBuffer: 0.05,
+        minRoutableUsd: CASE_THRESHOLD_USD
       }
     };
   }
@@ -44702,8 +44879,9 @@ var ExtendedSVKVesuStateManager = class {
   }
   /**
    * Turn pure rebalance() deltas into execution routes.
-   * Order: Vesu multiply (decrease/increase) → Extended lever → aggregated transfers
-   * (REALISE_PNL, EXTENDED_TO_WALLET + WAIT, WALLET_TO_VA, VESU_BORROW, VESU_REPAY, VA_TO_EXTENDED).
+   * Order: Vesu multiply decrease → Extended decrease → aggregated transfers
+   * (REALISE_PNL, EXTENDED_TO_WALLET + WAIT, WALLET_TO_VA, VESU_BORROW, VESU_REPAY, VA_TO_EXTENDED),
+   * then Vesu multiply increase and Extended increase (need VA / Extended funded first).
    */
   _buildLtvRoutesFromRebalanceDeltas(d) {
     const routes = [];
@@ -44715,6 +44893,7 @@ var ExtendedSVKVesuStateManager = class {
     const targetLtv = VesuConfig.targetLtv;
     const btcEps = 10 ** -COLLATERAL_PRECISION;
     let multiplyDebtRepayUsd = 0;
+    logger.info(`${this._tag}::_buildLtvRoutesFromRebalanceDeltas d=${JSON.stringify(d)}`);
     if (d.dVesuPosition < -btcEps) {
       const xBtc = -d.dVesuPosition;
       const transferUsdFromVesu = Math.max(0, d.dTransferVesuToExt);
@@ -44733,12 +44912,28 @@ var ExtendedSVKVesuStateManager = class {
       if (d.dVesuDebt < 0) {
         const needRepayUsd = -d.dVesuDebt * debtPrice;
         const multiplyRepayUsd = Math.min(needRepayUsd, swapLegMaxRepayUsd);
+        logger.info(`${this._tag}::_buildLtvRoutesFromRebalanceDeltas ${JSON.stringify({
+          needRepayUsd,
+          multiplyRepayUsd
+        })}`);
         debtTokenDelta = -(multiplyRepayUsd / debtPrice);
       } else {
         debtTokenDelta = -debtUsdFallback;
       }
       const debtAmtW3 = new Web3Number(debtTokenDelta.toFixed(USDC_TOKEN_DECIMALS), USDC_TOKEN_DECIMALS);
       multiplyDebtRepayUsd = Math.abs(debtTokenDelta) * debtPrice;
+      logger.info(`${this._tag}::_buildLtvRoutesFromRebalanceDeltas ${JSON.stringify({
+        debtTokenDelta,
+        debtUsdFallback,
+        swapLegMaxRepayUsd,
+        xBtc,
+        marginBtc,
+        swappedBtc,
+        transferUsdFromVesu,
+        debtPrice,
+        targetLtv,
+        multiplyDebtRepayUsd
+      })}`);
       routes.push({
         type: "VESU_MULTIPLY_DECREASE_LEVER" /* VESU_MULTIPLY_DECREASE_LEVER */,
         poolId: vesuAdapter.config.poolId,
@@ -44759,19 +44954,68 @@ var ExtendedSVKVesuStateManager = class {
       if (transferUsdFromVesu > CASE_THRESHOLD_USD) {
         this._budget.addToVA(transferUsdFromVesu);
       }
-    } else if (d.dVesuPosition > btcEps) {
+    }
+    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);
+    }
+    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);
+    logger.info(`${this._tag}::_buildLtvRoutesFromRebalanceDeltas extToWalletUsd=${extToWalletUsd}, negExtAvl=${negExtAvl}, negUpnl=${negUpnl}`);
+    if (extToWalletUsd > CASE_THRESHOLD_USD) {
+      this._getExtendedToWalletRoute(extToWalletUsd, routes);
+      hadExtendedOut = true;
+    } else {
+      if (d.dVesuDebt < 0) {
+        d.dVesuDebt += (negExtAvl < 0 && negExtAvl > -CASE_THRESHOLD_USD ? Math.abs(negExtAvl) : 0) + (negUpnl < 0 && negUpnl > -CASE_THRESHOLD_USD ? Math.abs(negUpnl) : 0);
+      }
+    }
+    logger.info(`${this._tag}::_buildLtvRoutesFromRebalanceDeltas d=${JSON.stringify(d)}`);
+    const walletPull = Math.abs(Math.min(0, d.dWalletUsd));
+    const walletToVaUsd = walletPull + extToWalletUsd;
+    if (walletToVaUsd > CASE_THRESHOLD_USD) {
+      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;
+    logger.info(`${this._tag}::_buildLtvRoutesFromRebalanceDeltas totalDebtRepayUsd=${totalDebtRepayUsd}`);
+    let standaloneRepayUsd = Math.max(0, totalDebtRepayUsd - multiplyDebtRepayUsd);
+    logger.info(`${this._tag}::_buildLtvRoutesFromRebalanceDeltas standaloneRepayUsd=${standaloneRepayUsd}`);
+    if (standaloneRepayUsd > this._budget.vaRawUsd) {
+      if (Math.abs(standaloneRepayUsd - this._budget.vaRawUsd) < CASE_THRESHOLD_USD) {
+        standaloneRepayUsd = this._budget.vaRawUsd;
+      } else {
+        throw new Error(`${this._tag}::_buildLtvRoutesFromRebalanceDeltas standaloneRepayUsd=${standaloneRepayUsd} > vaRawUsd=${this._budget.vaRawUsd}`);
+      }
+    }
+    if (standaloneRepayUsd > CASE_THRESHOLD_USD) {
+      this._buildVesuRepayRoutes(standaloneRepayUsd, routes);
+    }
+    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);
+    }
+    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),
@@ -44782,8 +45026,9 @@ var ExtendedSVKVesuStateManager = class {
         new Web3Number(Math.min(availableBorrowCapacity, vesuDepositAmount.toNumber()).toFixed(USDC_TOKEN_DECIMALS), USDC_TOKEN_DECIMALS)
       );
       const collPx = pool.collateralPrice || 1;
+      const marginUsdAmount = externalDepositAmount.toNumber() * (pool.debtPrice ?? 1);
       const swappedAmount = new Web3Number(
-        (externalDepositAmount.toNumber() * (pool.debtPrice ?? 1) / collPx).toFixed(6),
+        (marginUsdAmount / collPx).toFixed(6),
         vesuAdapter.config.collateral.decimals
       );
       const debtDeltaTokens = new Web3Number(
@@ -44807,17 +45052,9 @@ var ExtendedSVKVesuStateManager = class {
         collateralDelta,
         debtDeltaTokens
       );
+      this._budget.spendVA(marginUsdAmount);
     }
-    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) {
+    if (d.dExtPosition > btcEps) {
       const amt = new Web3Number(d.dExtPosition.toFixed(COLLATERAL_PRECISION), 8);
       routes.push({
         type: "EXTENDED_INCREASE_LEVER" /* EXTENDED_INCREASE_LEVER */,
@@ -44827,36 +45064,6 @@ var ExtendedSVKVesuStateManager = class {
       });
       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 ───────────────────────────────────────────
@@ -45015,48 +45222,76 @@ var ExtendedSVKVesuStateManager = class {
     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;
+    let dExtAvlWithdraw = 0, dExtUpnl = 0, dVaUsd = 0, dWalletUsd = 0, dVesuBorrowCapacity = 0, finalVaUsd = vaUsd, finalExtended = extAvlWithdraw + Math.max(extUpnl, 0);
     if (delta > 0) {
       let need = delta;
-      const takeWalletUsd = Math.min(walletUsd, need);
+      const eps = CASE_THRESHOLD_USD;
+      const takeWalletUsd = routableDrawAmount(walletUsd, need, eps);
       dWalletUsd -= takeWalletUsd;
       need -= takeWalletUsd;
-      const takeVaUsd = Math.min(vaUsd, need);
+      const takeVaUsd = routableDrawAmount(vaUsd, need, eps);
       dVaUsd -= takeVaUsd;
       need -= takeVaUsd;
-      const takeVesuBorrowCapacity = Math.min(vesuBorrowCapacity, need);
+      finalVaUsd -= takeVaUsd;
+      finalVaUsd += walletUsd - takeWalletUsd;
+      const takeVesuBorrowCapacity = routableDrawAmount(vesuBorrowCapacity, need, eps);
       dVesuBorrowCapacity -= takeVesuBorrowCapacity;
       need -= takeVesuBorrowCapacity;
+      finalVaUsd += vesuBorrowCapacity - takeVesuBorrowCapacity;
       const received = delta - need;
       const eco1Sum = extAvlWithdraw + extUpnl;
+      finalExtended += received;
       if (eco1Sum >= 0) {
         dExtAvlWithdraw += received;
       } else {
-        throw new Error(`${this._tag}: Unexpected case`);
+        const hole = -eco1Sum;
+        const fillUpnl = Math.min(received, hole);
+        dExtUpnl += fillUpnl;
+        dExtAvlWithdraw += received - fillUpnl;
+        finalExtended -= fillUpnl;
       }
-      if (need > 0) {
+      if (need > CASE_THRESHOLD_USD) {
         throw new Error(`${this._tag}: Insufficient funds to cover margin needs`);
       }
     } else if (delta < 0) {
       let need = -delta;
-      const takeExtAvlWithdraw = Math.min(extAvlWithdraw, need);
+      const takeExtAvlWithdraw = Math.min(Math.max(extAvlWithdraw, 0), need);
       dExtAvlWithdraw -= takeExtAvlWithdraw;
-      need -= takeExtAvlWithdraw;
-      const takeExtUpnl = Math.min(extUpnl, need);
+      const takeExtUpnl = Math.min(Math.max(extUpnl, 0), need);
       dExtUpnl -= takeExtUpnl;
-      need -= takeExtUpnl;
+      const netDrawableAmount = takeExtAvlWithdraw + takeExtUpnl;
+      if (netDrawableAmount > CASE_THRESHOLD_USD) {
+        need -= netDrawableAmount;
+        finalExtended -= netDrawableAmount;
+      }
       const sent = -delta - need;
       const eco2Sum = vaUsd + walletUsd + vesuBorrowCapacity;
+      const netWalletUsd = walletUsd < CASE_THRESHOLD_USD ? 0 : walletUsd;
+      finalVaUsd += sent + netWalletUsd;
       if (eco2Sum >= 0) {
         dWalletUsd += sent;
       } else {
         throw new Error(`${this._tag}: Unexpected case`);
       }
-      if (need > 0) {
+      if (need > CASE_THRESHOLD_USD) {
         throw new Error(`${this._tag}: Insufficient funds to cover margin needs`);
       }
     }
-    return { dExtAvlWithdraw, dExtUpnl, dVaUsd, dWalletUsd, dVesuBorrowCapacity, isExtendedToVesu: delta < 0 };
+    return { dExtAvlWithdraw, dExtUpnl, dVaUsd, dWalletUsd, dVesuBorrowCapacity, finalVaUsd, finalExtended, isExtendedToVesu: delta < 0 };
+  }
+  _scaleVesuPoolDeltasByFactor(deltas, scale) {
+    if (scale >= 1 - 1e-15) return deltas;
+    return deltas.map((d) => ({
+      ...d,
+      collateralDelta: new Web3Number(
+        (d.collateralDelta.toNumber() * scale).toFixed(COLLATERAL_PRECISION),
+        d.collateralToken.decimals
+      ),
+      debtDelta: new Web3Number(
+        (d.debtDelta.toNumber() * scale).toFixed(USDC_TOKEN_DECIMALS),
+        USDC_TOKEN_DECIMALS
+      )
+    }));
   }
   /**
    * 3. New Deposits / Excess Funds
@@ -45072,6 +45307,11 @@ var ExtendedSVKVesuStateManager = class {
    * Computes allocation split between Vesu and Extended, then sources
    * funds and creates lever-increase routes.
    *
+   * Order: {@link _rebalanceFunds} first → project VA / Extended liquid after the same funding
+   * routes (wallet→VA, borrow→VA, VA→Extended, Extended→wallet→VA) → ideal Vesu/Extended deltas
+   * from distributable split → cap common BTC by min(Vesu fundable, Extended fundable) → scale
+   * Vesu deltas and recompute Extended deltas so both sides stay matched.
+   *
    * Fund flow (single pass — avoid VA→Extended then Extended→wallet round-trips):
    *   1) Treat Vesu borrow headroom that the multiply route will consume as covering
    *      part of the Vesu USDC need (no standalone VESU_BORROW for that slice). Cap
@@ -45094,15 +45334,9 @@ var ExtendedSVKVesuStateManager = class {
       withdrawAmount
     );
     if (distributableAmount.toNumber() <= CASE_THRESHOLD_USD) return [];
-    const { vesuAllocationUsd, extendedAllocationUsd } = this._computeAllocationSplit(distributableAmount);
-    const vesuDeltas = this._computePerPoolCollateralDeltas(
-      vesuAllocationUsd
-    );
-    const extendedPositionDeltas = this._computeExtendedPositionDeltas(vesuDeltas);
-    const vesuDepositAmount = this._computeVesuDepositAmount(vesuDeltas);
     const vesuLeverage = calculateVesuLeverage();
     const extendedLeverage = calculateExtendedLevergae();
-    const { dExtAvlWithdraw, dExtUpnl, dVaUsd, dWalletUsd, dVesuBorrowCapacity, isExtendedToVesu } = this._rebalanceFunds({
+    const { dExtAvlWithdraw, dExtUpnl, dVaUsd, dWalletUsd, dVesuBorrowCapacity, isExtendedToVesu, finalVaUsd, finalExtended } = this._rebalanceFunds({
       extAvlWithdraw: this._budget.extAvailWithdraw,
       extUpnl: this._budget.extAvailUpnl,
       vaUsd: this._budget.vaUsd,
@@ -45111,6 +45345,23 @@ var ExtendedSVKVesuStateManager = class {
       vesuLeverage,
       extendedLeverage
     });
+    logger.info(`${this._tag}::_classifyDeposits dExtAvlWithdraw=${dExtAvlWithdraw}, dExtUpnl=${dExtUpnl}, dVaUsd=${dVaUsd}, dWalletUsd=${dWalletUsd}, dVesuBorrowCapacity=${dVesuBorrowCapacity}, isExtendedToVesu=${isExtendedToVesu}, finalVaUsd=${finalVaUsd}`);
+    let vesuDeltas = this._computePerPoolCollateralDeltas(new Web3Number(finalVaUsd.toFixed(USDC_TOKEN_DECIMALS), USDC_TOKEN_DECIMALS));
+    const collateralPrice = this._budget.vesuPools[0]?.collateralPrice ?? 0;
+    const collateralDecimals = this._budget.vesuPools[0]?.collateralToken.decimals ?? 0;
+    let _extendedPositionDelta = new Web3Number((finalExtended * extendedLeverage / collateralPrice).toFixed(USDC_TOKEN_DECIMALS), collateralDecimals).toFixedRoundDown(COLLATERAL_PRECISION);
+    logger.info(`${this._tag}::_classifyDeposits extendedPositionDelta=${_extendedPositionDelta}`);
+    logger.info(`${this._tag}::_classifyDeposits vesuDeltas=${JSON.stringify(vesuDeltas)}`);
+    assert(vesuDeltas.length == 1, "vesuDeltas should have only one delta");
+    const minPositionDelta = Math.min(vesuDeltas[0].collateralDelta.toNumber(), Number(_extendedPositionDelta));
+    logger.info(`${this._tag}::_classifyDeposits minPositionDelta=${minPositionDelta}`);
+    vesuDeltas[0].collateralDelta = new Web3Number(minPositionDelta.toFixed(COLLATERAL_PRECISION), vesuDeltas[0].collateralDelta.decimals);
+    const extendedPositionDeltas = [{
+      instrument: this._config.extendedAdapter.config.extendedMarketName ?? "BTC-USD",
+      delta: new Web3Number(minPositionDelta.toFixed(COLLATERAL_PRECISION), collateralDecimals)
+    }];
+    const vesuDepositAmount = this._computeVesuDepositAmount(vesuDeltas);
+    logger.info(`${this._tag}::_classifyDeposits vesuDepositAmount=${vesuDepositAmount}`);
     const routes = [];
     if (isExtendedToVesu) {
       if (dExtUpnl < 0) {
@@ -45138,13 +45389,6 @@ var ExtendedSVKVesuStateManager = class {
     }
     for (const vesuDelta of vesuDeltas) {
       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 availableBorrowCapacity = this._budget.vesuBorrowCapacity;
@@ -46124,14 +46368,6 @@ var _ExecutionService = class _ExecutionService {
         );
         return this._executeStandardCase(caseEntry, activeRoutes);
       }
-      const setLevResult = await this._config.extendedAdapter.setLeverage(calculateExtendedLevergae().toString(), this._config.extendedAdapter.config.extendedMarketName);
-      if (!setLevResult) {
-        logger.error(
-          `${this._tag}::_executeCoordinatedCase failed to set leverage`
-        );
-        results.push(this._failureResult(extendedRoute));
-        return results;
-      }
       const isIncrease = _ExecutionService.INCREASE_EXPOSURE_ROUTES.has(
         extendedRoute.type
       );
@@ -46152,8 +46388,9 @@ var _ExecutionService = class _ExecutionService {
         onChainCalls = callArrays.flat();
       } catch (err) {
         logger.error(
-          `${this._tag}::_executeCoordinatedCase on-chain call construction failed: ${err}`
+          `${this._tag}::_executeCoordinatedCase on-chain call construction failed:`
         );
+        console.error(err);
         await this._emitEvent("FAILURE" /* FAILURE */, {
           routeSummary: `coordinated on-chain build for case "${caseEntry.case.id}"`,
           error: `${err}`
@@ -46225,7 +46462,7 @@ var _ExecutionService = class _ExecutionService {
       }
       const timeoutMs = this._config.extendedFillTimeoutMs ?? DEFAULT_EXTENDED_FILL_TIMEOUT_MS;
       const extResult = await this._executeExtendedLimitOrderWithRecovery(
-        btcAmount,
+        Math.abs(btcAmount),
         executionPrice,
         side,
         {
@@ -46753,7 +46990,7 @@ var _ExecutionService = class _ExecutionService {
       return this._failureResult(route);
     }
     const closeResult = await this._executeExtendedLimitOrderWithRecovery(
-      positionToClose.toNumber(),
+      Math.abs(positionToClose.toNumber()),
       midPrice,
       "BUY" /* BUY */
     );
@@ -46771,7 +47008,7 @@ var _ExecutionService = class _ExecutionService {
       `${this._tag}::_executeRealisePnl reopening ${positionToClose.toNumber()} on ${route.instrument}`
     );
     const reopenResult = await this._executeExtendedLimitOrderWithRecovery(
-      positionToClose.toNumber(),
+      Math.abs(positionToClose.toNumber()),
       midPrice,
       "SELL" /* SELL */
     );
@@ -46825,7 +47062,7 @@ var _ExecutionService = class _ExecutionService {
       return this._failureResult(route);
     }
     const result = await this._executeExtendedLimitOrderWithRecovery(
-      route.amount.toNumber(),
+      Math.abs(route.amount.toNumber()),
       midPrice,
       "SELL" /* SELL */
     );
@@ -46873,7 +47110,7 @@ var _ExecutionService = class _ExecutionService {
       return this._failureResult(route);
     }
     const result = await this._executeExtendedLimitOrderWithRecovery(
-      route.amount.toNumber(),
+      Math.abs(route.amount.toNumber()),
       midPrice,
       "BUY" /* BUY */
     );
@@ -47496,16 +47733,16 @@ var VesuExtendedMultiplierStrategy = class _VesuExtendedMultiplierStrategy exten
     ];
   }
 };
-function getLooperSettings3(lstSymbol, underlyingSymbol, vaultSettings, pool1, extendedBackendReadUrl, extendedBackendWriteUrl, vaultIdExtended, minimumExtendedMovementAmount, minimumVesuMovementAmount, minimumExtendedRetriesDelayForOrderStatus, minimumExtendedPriceDifferenceForSwapOpen, maximumExtendedPriceDifferenceForSwapClosing) {
+function getLooperSettings3(collateralSymbol, underlyingSymbol, vaultSettings, pool1, extendedBackendReadUrl, extendedBackendWriteUrl, vaultIdExtended, minimumExtendedMovementAmount, minimumVesuMovementAmount, minimumExtendedRetriesDelayForOrderStatus, minimumExtendedPriceDifferenceForSwapOpen, maximumExtendedPriceDifferenceForSwapClosing) {
   vaultSettings.leafAdapters = [];
   const wbtcToken = Global.getDefaultTokens().find(
-    (token) => token.symbol === lstSymbol
+    (token) => token.symbol === collateralSymbol
   );
   const usdcToken = Global.getDefaultTokens().find(
     (token) => token.symbol === underlyingSymbol
   );
   const baseAdapterConfig = {
-    baseToken: wbtcToken,
+    baseToken: usdcToken,
     supportedPositions: [
       { asset: usdcToken, isDebt: true },
       { asset: wbtcToken, isDebt: false }
@@ -47605,7 +47842,7 @@ function getLooperSettings3(lstSymbol, underlyingSymbol, vaultSettings, pool1, e
     vaultAddress: vaultSettings.vaultAddress,
     vaultAllocator: vaultSettings.vaultAllocator,
     manager: vaultSettings.manager,
-    asset: wbtcToken.address
+    asset: usdcToken.address
   });
   vaultSettings.leafAdapters.push(() => vesuMultiplyAdapter.getDepositLeaf());
   vaultSettings.leafAdapters.push(() => vesuMultiplyAdapter.getWithdrawLeaf());
@@ -47739,6 +47976,39 @@ var re7UsdcPrimeDevansh = {
   minimumWBTCDifferenceForAvnuSwap: MINIMUM_WBTC_DIFFERENCE_FOR_AVNU_SWAP,
   walletAddress: "0x024b563C1C7d41B32BF4EFB9F38828508a65Be2d6e25268E9f63F22C5e9E51c5"
 };
+var pureUsdc = {
+  vaultAddress: ContractAddr.from(
+    "0x745c972db65bdee10022fd875dd328c7f40a90849135b6a0f875a40f3c632ae"
+  ),
+  manager: ContractAddr.from(
+    "0x364e0894edefb616ec090f57f5c0274517fcd98ab276ae1f021c5e962fa1deb"
+  ),
+  vaultAllocator: ContractAddr.from(
+    "0x6fceed28e03a96091877568893df0dd89b9bb80fec30da2b742dacbd5526179"
+  ),
+  redeemRequestNFT: ContractAddr.from(
+    "0x501c2b87728e22c6dfcebe4c0b2b3a9fba5845606e4d59fa7bf591badcbb42"
+  ),
+  aumOracle: ContractAddr.from(
+    "0x6ccd95f5765242695d3c75e1440b1d0b30efac8babb864ce15729977b97cb82"
+  ),
+  leafAdapters: [],
+  adapters: [],
+  targetHealthFactor: 1.4,
+  minHealthFactor: 1.35,
+  underlyingToken: Global.getDefaultTokens().find(
+    (token) => token.symbol === "USDC"
+  ),
+  quoteAmountToFetchPrice: new Web3Number(
+    "0.001",
+    Global.getDefaultTokens().find((token) => token.symbol === "USDC").decimals
+  ),
+  borrowable_assets: [
+    Global.getDefaultTokens().find((token) => token.symbol === "USDC")
+  ],
+  minimumWBTCDifferenceForAvnuSwap: MINIMUM_WBTC_DIFFERENCE_FOR_AVNU_SWAP,
+  walletAddress: "0x058571C23da5FEdd4e36003FAE3fE2fA9782f2692E552f081839142B10770D0B"
+};
 var VesuExtendedTestStrategies = (extendedBackendReadUrl, extendedBackendWriteUrl, vaultIdExtended, minimumExtendedMovementAmount, minimumVesuMovementAmount, minimumExtendedRetriesDelayForOrderStatus, minimumExtendedPriceDifferenceForSwapOpen, maximumExtendedPriceDifferenceForSwapClosing) => {
   return [
     getStrategySettingsVesuExtended(
@@ -47755,14 +48025,29 @@ var VesuExtendedTestStrategies = (extendedBackendReadUrl, extendedBackendWriteUr
       minimumExtendedRetriesDelayForOrderStatus,
       minimumExtendedPriceDifferenceForSwapOpen,
       maximumExtendedPriceDifferenceForSwapClosing
+    ),
+    getStrategySettingsVesuExtended(
+      "WBTC",
+      "USDC",
+      pureUsdc,
+      false,
+      false,
+      extendedBackendReadUrl,
+      extendedBackendWriteUrl,
+      vaultIdExtended,
+      minimumExtendedMovementAmount,
+      minimumVesuMovementAmount,
+      minimumExtendedRetriesDelayForOrderStatus,
+      minimumExtendedPriceDifferenceForSwapOpen,
+      maximumExtendedPriceDifferenceForSwapClosing
     )
   ];
 };
-function getStrategySettingsVesuExtended(lstSymbol, underlyingSymbol, addresses, isPreview = false, isLST, extendedBackendReadUrl, extendedBackendWriteUrl, vaultIdExtended, minimumExtendedMovementAmount, minimumVesuMovementAmount, minimumExtendedRetriesDelayForOrderStatus, minimumExtendedPriceDifferenceForSwapOpen, maximumExtendedPriceDifferenceForSwapClosing) {
+function getStrategySettingsVesuExtended(collateralSymbol, underlyingSymbol, addresses, isPreview = false, isLST, extendedBackendReadUrl, extendedBackendWriteUrl, vaultIdExtended, minimumExtendedMovementAmount, minimumVesuMovementAmount, minimumExtendedRetriesDelayForOrderStatus, minimumExtendedPriceDifferenceForSwapOpen, maximumExtendedPriceDifferenceForSwapClosing) {
   return {
     id: `extended_${underlyingSymbol.toLowerCase()}_test`,
     name: `Extended Test ${underlyingSymbol}`,
-    description: getDescription3(lstSymbol, underlyingSymbol),
+    description: getDescription3(collateralSymbol, underlyingSymbol),
     address: addresses.vaultAddress,
     launchBlock: 0,
     type: "Other",
@@ -47776,7 +48061,7 @@ function getStrategySettingsVesuExtended(lstSymbol, underlyingSymbol, addresses,
       )
     ],
     additionalInfo: getLooperSettings3(
-      lstSymbol,
+      collateralSymbol,
       underlyingSymbol,
       addresses,
       VesuPools.Re7USDCPrime,
@@ -47797,8 +48082,8 @@ function getStrategySettingsVesuExtended(lstSymbol, underlyingSymbol, addresses,
     auditUrl: AUDIT_URL4,
     protocols: [Protocols.ENDUR, Protocols.VESU],
     contractDetails: getContractDetails(addresses),
-    faqs: getFAQs2(lstSymbol, underlyingSymbol, isLST),
-    investmentSteps: getInvestmentSteps(lstSymbol, underlyingSymbol),
+    faqs: getFAQs2(collateralSymbol, underlyingSymbol, isLST),
+    investmentSteps: getInvestmentSteps(collateralSymbol, underlyingSymbol),
     isPreview,
     apyMethodology: isLST ? "Current annualized APY in terms of base asset of the LST. There is no additional fee taken by Troves on LST APY. We charge a 10% performance fee on the additional gain which is already accounted in the APY shown." : "Current annualized APY in terms of base asset of the Yield Token. There is no additional fee taken by Troves on yield token APY. We charge a 10% performance fee on the additional gain which is already accounted in the APY shown.",
     security: {