@strkfarm/sdk 2.0.0-dev.33 → 2.0.0-dev.34

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

@@ -2,7 +2,7 @@ import { ContractAddr, Web3Number } from "@/dataTypes";
 import { IConfig, TokenInfo } from "@/interfaces";
 import { PricerBase } from "@/modules/pricerBase";
 import { ERC20 } from "@/modules";
-import { assert, logger } from "@/utils";
+import { assert, HealthFactorMath, logger } from "@/utils";
 import { ExtendedAdapter } from "../../universal-adapters/extended-adapter";
 import { VesuMultiplyAdapter } from "../../universal-adapters/vesu-multiply-adapter";
 import { AssetOperationType, AssetOperationStatus } from "@/modules/ExtendedWrapperSDk";
@@ -1684,6 +1684,160 @@ export function createSolveBudgetFromRawState(params: {
   return budget;
 }
 
+function assertRouteSanityAndAdjust(route: ExecutionRoute, availableAmount: number): ExecutionRoute {
+  if (!(route as any).amount) {
+    throw new Error(`Invalid route given to assertRouteSanityAndAdjust: ${JSON.stringify(route)}`);
+  }
+
+  const routeAmount = (route as any).amount.toNumber();
+  if (routeAmount <= availableAmount) {
+    return route; // all cool
+  }
+  if ((routeAmount - availableAmount) <= CASE_THRESHOLD_USD) {
+    return { ...route, amount: new Web3Number(availableAmount, (route as any).amount.decimals) } as any;
+  }
+  throw new Error(`Route amount ${routeAmount} exceeds available amount ${availableAmount}, Route name: ${route.type}`);
+}
+
+function assertVesuMultiplyRouteSanityAndAdjust(route: VesuMultiplyRoute, availableAmount: number, state: SolveBudget, isIncrease: boolean) {
+  const btcPrice = state.vesuPoolState.collateralPrice;
+  // post state should be healthy
+  const totalCollateralAmount = isIncrease ?
+    route.marginAmount.plus(route.swappedCollateralAmount).plus(state.vesuPoolState.collateralAmount) :
+    state.vesuPoolState.collateralAmount.minus(route.marginAmount.plus(route.swappedCollateralAmount));
+  const totalDebtAmount = isIncrease ?
+    route.debtAmount.plus(state.vesuPoolState.debtAmount) :
+    state.vesuPoolState.debtAmount.minus(route.debtAmount);
+  const newHF = HealthFactorMath.getHealthFactor(
+    totalCollateralAmount,
+    btcPrice,
+    VesuConfig.maxLtv,
+    totalDebtAmount,
+    state.vesuPoolState.debtPrice,
+  );
+  const idealHF = VesuConfig.maxLtv / VesuConfig.targetLtv - 0.05;
+  assert(newHF >= idealHF, `SolveBudget::applyRoutesAndVerifyLtvState newHF=${newHF} < idealHF=${idealHF}`);
+}
+
+function applyRoutesAndVerifyLtvState(
+  state: SolveBudget,
+  routes: ExecutionRoute[],
+): void {
+  const btcPrice = state.vesuPoolState.collateralPrice;
+  const adjustedRouters: ExecutionRoute[] = [...routes];
+  let index = 0;
+  for (const r of routes) {
+    switch (r.type) {
+      case RouteType.WALLET_TO_VA: {
+        const adjustedRoute = assertRouteSanityAndAdjust(r, state.walletUsd);
+        const amt = (adjustedRoute as TransferRoute).amount.toNumber();
+        state.spendWallet(amt);
+        state.addToVA(amt);
+        break;
+      }
+      case RouteType.VESU_REPAY: {
+        const adjustedRoute = assertRouteSanityAndAdjust(r, state.vaRawUsd);
+        const amt = Math.abs((adjustedRoute as VesuDebtRoute).amount.toNumber());
+        state.repayVesuBorrowCapacity(amt);
+        state.spendVA(amt);
+        break;
+      }
+      case RouteType.EXTENDED_TO_WALLET: {
+        const adjustedRoute = assertRouteSanityAndAdjust(r, state.extAvailWithdraw);
+        const amt = (adjustedRoute as TransferRoute).amount.toNumber();
+        state.addToWallet(amt);
+        state.spendExtAvailTrade(amt);
+        break;
+      }
+      case RouteType.REALISE_PNL: {
+        const amt = (r as RealisePnlRoute).amount.toNumber();
+        state.spendExtAvailUpnl(amt);
+        state.addToExtAvailTrade(amt);
+        break;
+      }
+      case RouteType.VA_TO_EXTENDED: {
+        const adjustedRoute = assertRouteSanityAndAdjust(r, state.vaRawUsd);
+        const amt = (adjustedRoute as TransferRoute).amount.toNumber();
+        state.spendVA(amt);
+        state.addToExtAvailTrade(amt);
+        break;
+      }
+      case RouteType.WALLET_TO_EXTENDED: {
+        const adjustedRoute = assertRouteSanityAndAdjust(r, state.walletUsd);
+        const amt = (adjustedRoute as TransferRoute).amount.toNumber();
+        state.spendWallet(amt);
+        state.addToExtAvailTrade(amt);
+        break;
+      }
+      case RouteType.VESU_BORROW: {
+        // assert amount being borrowed is acceptable
+        const borrowedAmount = (r as VesuDebtRoute).amount.toNumber();
+        const currentCollateralAmount = state.vesuPoolState.collateralAmount.toNumber();
+        const currentDebtAmount = state.vesuPoolState.debtAmount.toNumber();
+        const maxDebtAmount = HealthFactorMath.getMaxDebtAmount(
+          new Web3Number(currentCollateralAmount, state.vesuPoolState.collateralToken.decimals),
+          state.vesuPoolState.collateralPrice,
+          VesuConfig.maxLtv,
+          (VesuConfig.maxLtv / VesuConfig.targetLtv - 0.05), // e.g. if ideal HF is 1.4, upto 1.35 is ok.
+          state.vesuPoolState.debtPrice,
+          state.vesuPoolState.debtToken,
+        );
+        const availableDebtAmount = maxDebtAmount.minus(new Web3Number(currentDebtAmount, state.vesuPoolState.debtToken.decimals));
+        if (!(availableDebtAmount.plus(CASE_THRESHOLD_USD).greaterThan(borrowedAmount))) {
+          throw new Error(`SolveBudget::applyRoutesAndVerifyLtvState availableDebtAmount=${availableDebtAmount.toNumber()} < borrowedAmount=${borrowedAmount}`);
+        }
+        state.spendVesuBorrowCapacity(borrowedAmount);
+        state.addToVA(borrowedAmount);
+        break;
+      }
+      case RouteType.VESU_MULTIPLY_INCREASE_LEVER: {
+        const mr = r as VesuMultiplyRoute;
+
+        // assert va has enough balance
+        assertVesuMultiplyRouteSanityAndAdjust(mr, state.vaRawUsd, state, true);
+
+        state.applyVesuDelta(
+          mr.poolId,
+          mr.collateralToken,
+          mr.debtToken,
+          mr.marginAmount.plus(mr.swappedCollateralAmount),
+          mr.debtAmount,
+        );
+        state.spendVA(mr.marginAmount.toNumber() * btcPrice);
+        break;
+      }
+      case RouteType.VESU_MULTIPLY_DECREASE_LEVER: {
+        const mr = r as VesuMultiplyRoute;
+        // assert va has enough balance
+        assertVesuMultiplyRouteSanityAndAdjust(mr, state.vaRawUsd, state, false);
+        state.applyVesuDelta(
+          mr.poolId,
+          mr.collateralToken,
+          mr.debtToken,
+          new Web3Number(mr.marginAmount.negated().minus(mr.swappedCollateralAmount).toFixed(8), mr.marginAmount.decimals),
+          mr.debtAmount,
+        );
+        // USDC from the margin leg hits VA before VA_TO_EXTENDED (matches _buildLtvRoutesFromRebalanceDeltas).
+        const marginBtc = mr.marginAmount.toNumber();
+        if (marginBtc > 10 ** -COLLATERAL_PRECISION) {
+          state.addToVA(marginBtc * btcPrice);
+        }
+        break;
+      }
+      case RouteType.EXTENDED_DECREASE_LEVER:
+      case RouteType.EXTENDED_INCREASE_LEVER: {
+        const er = r as ExtendedLeverRoute;
+        // mostly not required, as any lever changes in extended are already strictly governed by margin conditions
+        state.applyExtendedExposureDelta(er.instrument, er.amount, btcPrice);
+        break;
+      }
+      case RouteType.RETURN_TO_WAIT:
+        break;
+    }
+    index++;
+  }
+}
+
 // ─── State Manager ─────────────────────────────────────────────────────────────
 
 /**
@@ -1721,7 +1875,7 @@ export class ExtendedSVKVesuStateManager {
   async solve(
     withdrawAmount: Web3Number = new Web3Number(0, USDC_TOKEN_DECIMALS),
   ): Promise<SolveResult | null> {
-    await this._refresh();
+    const gaurdrailBudget = await this._refresh();
     if (Math.abs(this._budget.extPendingDeposit) > 0) {
       logger.warn(`${this._tag}::solve extPendingDeposit=${this._budget.extPendingDeposit}`);
       return null;
@@ -1771,6 +1925,14 @@ export class ExtendedSVKVesuStateManager {
     //   its own routes with amounts and state info.
     const cases = this._classifyCases(withdrawAmount);
 
+    // validate routes
+    for(const c of cases) {
+      applyRoutesAndVerifyLtvState(gaurdrailBudget, c.routes);
+    }
+    const extendedPositionSize = gaurdrailBudget.extendedPositionsView[0].size.toNumber();
+    const vesuPositionSize = gaurdrailBudget.vesuPoolState.collateralAmount.toNumber();
+    assert(Math.abs(extendedPositionSize - vesuPositionSize) <= 0.00001, "extended positions size mismatch");
+
     const result: SolveResult = {
       cases,
       // ignore these fields for now. only cases are relevant.
@@ -1796,7 +1958,7 @@ export class ExtendedSVKVesuStateManager {
    * Reads all on-chain and off-chain state in parallel and stores
    * results in private instance variables.
    */
-  private async _refresh(): Promise<void> {
+  private async _refresh(): Promise<SolveBudget> {
     logger.info(`${this._tag}::_refresh starting`);
 
     const [
@@ -1827,7 +1989,7 @@ export class ExtendedSVKVesuStateManager {
       walletBalance,
     );
 
-    this._budget = createSolveBudgetFromRawState({
+    const data = {
       assetToken: this._config.assetToken,
       usdcToken: this._config.usdcToken,
       unusedBalance,
@@ -1854,7 +2016,10 @@ export class ExtendedSVKVesuStateManager {
           new Web3Number(0, USDC_TOKEN_DECIMALS),
       },
       vesuPoolStates,
-    });
+    }
+    this._budget = createSolveBudgetFromRawState(data);
+
+    const gaurdrailBudget = createSolveBudgetFromRawState({...data});
     this._budget.logStateSummary();
 
     const totalUnusedUsd = unusedBalance.reduce(
@@ -1874,6 +2039,8 @@ export class ExtendedSVKVesuStateManager {
       `extendedBalance::pendingDeposit: ${extendedBalance?.pendingDeposit.toNumber()} - ` +
       `extendedBalance::equity: ${extendedBalance?.equity.toNumber()}`,
     );
+
+    return gaurdrailBudget;
   }
 
   // todo add communication check with python server of extended. if not working, throw error in solve function.