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

package/src/strategies/vesu-extended-strategy/services/ltv-imbalance-rebalance-math.ts

@@ -29,11 +29,18 @@
 // to track remaining balances across sequential draws.
 // ============================================================
 
+import { logger } from "@/utils";
+
 // ---- Types ----
 
-interface RebalanceConfig {
+export interface RebalanceConfig {
   positionPrecision: number;  // decimal places for BTC rounding, e.g. 4
   hfBuffer: number;           // HF tolerance before acting, e.g. 0.05
+  /**
+   * USD below this cannot be executed as a standalone transfer/borrow/repay step
+   * (matches execution-layer dust threshold). Default 0 keeps pure math tests unchanged.
+   */
+  minRoutableUsd?: number;
 }
 
 export interface ExtendedState {
@@ -227,19 +234,32 @@ interface DrawResult {
   unmet: number;                           // remaining USD still needed
 }
 
+/**
+ * Portion of `need` we can take from `avail` such that execution can actually move it.
+ * Chunks at or below `minRoutable` are skipped (caller may satisfy `need` from another source
+ * or leave it unmet); matches VA/wallet/borrow dust rules in the state manager.
+ */
+function routableDrawAmount(avail: number, need: number, minRoutable: number): number {
+  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;
+}
+
 /**
  * Draw `need` USD from funding sources in strict priority order.
  * Mutates `pool` balances so subsequent draws see reduced availability.
- * Each source contributes min(available, remaining_need).
+ * Each source contributes a routable amount (see {@link routableDrawAmount}).
  */
-function drawFunds(need: number, keys: FundKey[], pool: FundingPool): DrawResult {
+function drawFunds(need: number, keys: FundKey[], pool: FundingPool, minRoutable: number): DrawResult {
   const draws: Partial<Record<FundKey, number>> = {};
   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;
@@ -247,6 +267,27 @@ function drawFunds(need: number, keys: FundKey[], pool: FundingPool): DrawResult
   return { draws, filled: need - unmet, unmet };
 }
 
+/**
+ * Withdraw + uPnL are separate buckets but execution moves them in one EXTENDED_TO_WALLET leg
+ * (waterfall inside the budget). Apply {@link routableDrawAmount} to their **sum**, then drain
+ * avl-withdraw first, then uPnL — matches spendExtAvailTrade in the state-manager budget.
+ */
+function drawExtendedAggregated(need: number, pool: FundingPool, minRoutable: number): DrawResult {
+  const draws: Partial<Record<FundKey, number>> = {};
+  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 };
+}
+
 /** Sum draw amounts for a subset of keys (e.g. all Extended-sourced draws). */
 function sumKeys(draws: Partial<Record<FundKey, number>>, keys: FundKey[]): number {
   return keys.reduce((s, k) => s + (draws[k] ?? 0), 0);
@@ -286,12 +327,13 @@ interface Phase1Result {
  * Priority: wallet → VA → vesuBorrowCapacity.
  * Funds received increase Extended equity (dExtAvlWithdraw).
  */
-function fixExtMargin(ext: ExtendedState, price: number, pool: FundingPool): { d: RebalanceDeltas; unmet: number } {
+function fixExtMargin(ext: ExtendedState, price: number, pool: FundingPool, config: RebalanceConfig): { d: RebalanceDeltas; unmet: number } {
   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);
 
   // All filled amount lands as Extended equity
@@ -310,7 +352,7 @@ function fixExtMargin(ext: ExtendedState, price: number, pool: FundingPool): { d
  * Priority: VA → wallet → extAvlWithdraw → extUpnl.
  * Repaid amount reduces Vesu debt (dVesuDebt).
  */
-function fixVesuMargin(vesu: VesuState, price: number, pool: FundingPool, hfBuffer: number): { d: RebalanceDeltas; unmet: number } {
+function fixVesuMargin(vesu: VesuState, price: number, pool: FundingPool, hfBuffer: number, config: RebalanceConfig): { d: RebalanceDeltas; unmet: number } {
   const d = emptyDeltas();
   const hf = computeVesuHF(vesu, price);
 
@@ -320,14 +362,19 @@ function fixVesuMargin(vesu: VesuState, price: number, pool: FundingPool, hfBuff
   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;
 
   // Convert filled USD back to debt tokens for the repayment delta
   d.dVesuDebt -= filled / vesu.debtPrice;
 
   // Funds withdrawn from Extended and sent to Vesu = negative transfer
-  const fromExt = sumKeys(draws, ['extAvlWithdraw', 'extUpnl']);
+  const fromExt = sumKeys(rExt.draws, ['extAvlWithdraw', 'extUpnl']);
   if (fromExt > 0) d.dTransferVesuToExt -= fromExt;
 
   return { d, unmet };
@@ -339,8 +386,8 @@ function fixVesuMargin(vesu: VesuState, price: number, pool: FundingPool, hfBuff
  * Returns combined deltas and any unresolved deficits.
  */
 function phase1(ext: ExtendedState, vesu: VesuState, price: number, pool: FundingPool, config: RebalanceConfig): Phase1Result {
-  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,
@@ -564,9 +611,11 @@ function roundFinalPosition(
 function phase2(
   extPos: number, vesuPos: number, extEquity: number,
   vesuDebt: number, vesu: VesuState, extLev: number, price: number,
-  pool: FundingPool, precision: number,
+  pool: FundingPool, config: RebalanceConfig,
 ): RebalanceDeltas {
   const d = emptyDeltas();
+  const precision = config.positionPrecision;
+  const minR = config.minRoutableUsd ?? 0;
   const targetLTV = computeVesuTargetLTV(vesu);
 
   // ---- Step 1: Try to close gap using available funding sources ----
@@ -583,8 +632,11 @@ function phase2(
       // Extended is larger — try to grow Vesu
       // Vesu growth is leveraged: equity cost = gapBtc × price × (1 - targetLTV)
       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;
 
       // Convert filled equity into leveraged position growth
       const grownBtc = computeVesuGrowthFromEquity(filled, vesu, price);
@@ -595,7 +647,7 @@ function phase2(
       d.dVesuDebt += computeVesuGrowthDebt(grownBtc, vesu, price);
 
       // Track ext → vesu fund movement
-      const fromExt = sumKeys(draws, ['extAvlWithdraw', 'extUpnl']);
+      const fromExt = sumKeys(rExt.draws, ['extAvlWithdraw', 'extUpnl']);
       if (fromExt > 0) d.dTransferVesuToExt -= fromExt;
 
     } else {
@@ -603,7 +655,7 @@ function phase2(
       // Extended growth is leveraged: margin cost = gapBtc × price / extLeverage
       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);
 
       // Each $1 of margin creates extLeverage/price BTC of position
@@ -706,6 +758,7 @@ function phase2(
  * then solves the unified equation for anything left.
  */
 function rebalance(inputs: RebalanceInputs): RebalanceDeltas {
+  logger.info(`ltv-imbalance-rebalance-math::rebalance inputs=${JSON.stringify(inputs)}`);
   const { ext, vesu, btcPrice, config } = inputs;
   const pool: FundingPool = { ...inputs.funding };
 
@@ -721,10 +774,10 @@ function rebalance(inputs: RebalanceInputs): RebalanceDeltas {
 
   const p2 = phase2(
     effExtPos, effVesuPos, effExtEquity, effVesuDebt,
-    vesu, ext.leverage, btcPrice, pool, config.positionPrecision,
+    vesu, ext.leverage, btcPrice, pool, config,
   );
 
   return mergeDeltas(p1.deltas, p2);
 }
 
-export { rebalance, RebalanceInputs, RebalanceDeltas, RebalanceConfig };
+export { rebalance, RebalanceInputs, RebalanceDeltas, routableDrawAmount };

package/src/strategies/vesu-extended-strategy/vesu-extended-strategy.tsx

@@ -553,7 +553,7 @@ export class VesuExtendedMultiplierStrategy<
  * wiring function that connects the strategy to its underlying protocol adapters.
  */
 function getLooperSettings(
-  lstSymbol: string,
+  collateralSymbol: string,
   underlyingSymbol: string,
   vaultSettings: VesuExtendedStrategySettings,
   pool1: ContractAddr,
@@ -569,14 +569,14 @@ function getLooperSettings(
   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: BaseAdapterConfig = {
-    baseToken: wbtcToken,
+    baseToken: usdcToken,
     supportedPositions: [
       { asset: usdcToken, isDebt: true },
       { asset: wbtcToken, isDebt: false },
@@ -688,7 +688,7 @@ function getLooperSettings(
     vaultAddress: vaultSettings.vaultAddress,
     vaultAllocator: vaultSettings.vaultAllocator,
     manager: vaultSettings.manager,
-    asset: wbtcToken.address,
+    asset: usdcToken.address,
   });
 
   vaultSettings.leafAdapters.push(() => vesuMultiplyAdapter.getDepositLeaf());
@@ -841,6 +841,41 @@ const re7UsdcPrimeDevansh: VesuExtendedStrategySettings = {
   walletAddress: '0x024b563C1C7d41B32BF4EFB9F38828508a65Be2d6e25268E9f63F22C5e9E51c5',
 };
 
+const pureUsdc: VesuExtendedStrategySettings = {
+  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',
+};
+
 export const VesuExtendedTestStrategies = (
   extendedBackendReadUrl: string,
   extendedBackendWriteUrl: string,
@@ -867,6 +902,21 @@ export const VesuExtendedTestStrategies = (
       minimumExtendedPriceDifferenceForSwapOpen,
       maximumExtendedPriceDifferenceForSwapClosing,
     ),
+    getStrategySettingsVesuExtended(
+      "WBTC",
+      "USDC",
+      pureUsdc,
+      false,
+      false,
+      extendedBackendReadUrl,
+      extendedBackendWriteUrl,
+      vaultIdExtended,
+      minimumExtendedMovementAmount,
+      minimumVesuMovementAmount,
+      minimumExtendedRetriesDelayForOrderStatus,
+      minimumExtendedPriceDifferenceForSwapOpen,
+      maximumExtendedPriceDifferenceForSwapClosing,
+    ),
   ];
 };
 
@@ -875,7 +925,7 @@ export const VesuExtendedTestStrategies = (
  * including adapter wiring, risk configuration, FAQ, and UI description.
  */
 function getStrategySettingsVesuExtended(
-  lstSymbol: string,
+  collateralSymbol: string,
   underlyingSymbol: string,
   addresses: VesuExtendedStrategySettings,
   isPreview: boolean = false,
@@ -892,7 +942,7 @@ function getStrategySettingsVesuExtended(
   return {
     id: `extended_${underlyingSymbol.toLowerCase()}_test`,
     name: `Extended Test ${underlyingSymbol}`,
-    description: getDescription(lstSymbol, underlyingSymbol),
+    description: getDescription(collateralSymbol, underlyingSymbol),
     address: addresses.vaultAddress,
     launchBlock: 0,
     type: "Other",
@@ -906,7 +956,7 @@ function getStrategySettingsVesuExtended(
       )!,
     ],
     additionalInfo: getLooperSettings(
-      lstSymbol,
+      collateralSymbol,
       underlyingSymbol,
       addresses,
       VesuPools.Re7USDCPrime,
@@ -929,8 +979,8 @@ function getStrategySettingsVesuExtended(
     auditUrl: AUDIT_URL,
     protocols: [Protocols.ENDUR, Protocols.VESU],
     contractDetails: getContractDetails(addresses),
-    faqs: getFAQs(lstSymbol, underlyingSymbol, isLST),
-    investmentSteps: getInvestmentSteps(lstSymbol, underlyingSymbol),
+    faqs: getFAQs(collateralSymbol, underlyingSymbol, isLST),
+    investmentSteps: getInvestmentSteps(collateralSymbol, underlyingSymbol),
     isPreview: 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."

package/src/utils/cacheClass.ts

@@ -5,6 +5,7 @@ interface CacheData {
 }
 export class CacheClass {
     readonly cache: Map<string, CacheData> = new Map();
+    isCacheEnabled: boolean = true;
 
     setCache(key: string, data: any, ttl: number = 60000): void {
         const timestamp = Date.now();
@@ -13,7 +14,7 @@ export class CacheClass {
 
     getCache<T>(key: string): T | null {
         const cachedData = this.cache.get(key);
-        if (!cachedData || !this.isCacheValid(key)) {
+        if (!cachedData || !this.isCacheValid(key) || !this.isCacheEnabled) {
             return null;
         }
         return cachedData.data;
@@ -26,4 +27,12 @@ export class CacheClass {
         const { timestamp, ttl } = cachedData;
         return Date.now() - timestamp <= ttl;
     }
-}
+
+    disableCache(): void {
+        this.isCacheEnabled = false;
+    }
+
+    enableCache(): void {
+        this.isCacheEnabled = true;
+    }
+}