@strkfarm/sdk 2.0.0-dev.35 → 2.0.0-dev.37

package/src/strategies/universal-adapters/avnu-adapter.ts

@@ -7,7 +7,6 @@ import {
 } from "./baseAdapter";
 import { toBigInt } from "./adapter-utils";
 import { Protocols } from "@/interfaces";
-import { MAX_DELAY } from "../vesu-extended-strategy/utils/constants";
 import { SupportedPosition } from "./baseAdapter";
 import { PositionAPY, APYType, PositionAmount } from "./baseAdapter";
 import { Web3Number } from "@/dataTypes";
@@ -15,17 +14,25 @@ import { PositionInfo } from "./baseAdapter";
 import { ManageCall } from "./baseAdapter";
 import { ContractAddr } from "@/dataTypes";
 import { AVNU_EXCHANGE } from "./adapter-utils";
-import { MAX_RETRIES } from "../vesu-extended-strategy/utils/constants";
 import { Quote } from "@avnu/avnu-sdk";
 import { hash, uint256 } from "starknet";
 import { AvnuWrapper } from "@/modules/avnu";
 import axios from "axios";
 import { SIMPLE_SANITIZER } from "./adapter-utils";
-import { returnFormattedAmount } from "../vesu-extended-strategy/utils/helper";
 import { assert, logger } from "@/utils";
 import { Global } from "@/global";
 import { TokenInfo } from "@/interfaces";
 import { ERC20 } from "@/modules";
+import { MAX_AVNU_RETRY_DELAY } from "../constants";
+
+export interface AvnuDepositParams extends DepositParams {
+  minAmount?: Web3Number;
+}
+
+export interface AvnuWithdrawParams extends WithdrawParams {
+  minAmount?: Web3Number;
+}
+
 export interface AvnuAdapterConfig extends BaseAdapterConfig {
   baseUrl: string;
   avnuContract: ContractAddr; //0x04270219d365d6b017231b52e92b3fb5d7c8378b05e9abc97724537a80e93b0f
@@ -34,7 +41,7 @@ export interface AvnuAdapterConfig extends BaseAdapterConfig {
   maximumExtendedPriceDifferenceForSwapClosing: number;
 }
 
-export class AvnuAdapter extends BaseAdapter<DepositParams, WithdrawParams> {
+export class AvnuAdapter extends BaseAdapter<AvnuDepositParams, AvnuWithdrawParams> {
   readonly config: AvnuAdapterConfig;
   protected avnuWrapper: AvnuWrapper;
   lastSwapPriceInfo: SwapPriceInfo | null = null;
@@ -91,7 +98,7 @@ export class AvnuAdapter extends BaseAdapter<DepositParams, WithdrawParams> {
   }
 
   private async buildSwapCalls(
-    params: DepositParams | WithdrawParams,
+    params: AvnuDepositParams | AvnuWithdrawParams,
     fromToken: TokenInfo,
     toToken: TokenInfo,
     // NOTE : this is a direction flag that we are swapping in this direction
@@ -129,6 +136,7 @@ export class AvnuAdapter extends BaseAdapter<DepositParams, WithdrawParams> {
     const getCalldata = await this.avnuWrapper.getSwapCallData(
       quote,
       vaultAllocator.address,
+      params.minAmount,
     );
     const swapCallData = getCalldata[0];
     const approveAmount = uint256.bnToUint256(params.amount.toWei());
@@ -260,7 +268,7 @@ export class AvnuAdapter extends BaseAdapter<DepositParams, WithdrawParams> {
     return [];
   }
 
-  async getDepositCall(params: DepositParams): Promise<ManageCall[]> {
+  async getDepositCall(params: AvnuDepositParams): Promise<ManageCall[]> {
     try {
       const fromToken = this.config.supportedPositions[0].asset; //usdc
       const toToken = this.config.supportedPositions[1].asset; //wbtc
@@ -278,7 +286,7 @@ export class AvnuAdapter extends BaseAdapter<DepositParams, WithdrawParams> {
   }
 
   //Swap wbtc to usdc
-  async getWithdrawCall(params: WithdrawParams): Promise<ManageCall[]> {
+  async getWithdrawCall(params: AvnuWithdrawParams): Promise<ManageCall[]> {
     try {
       const toToken = this.config.supportedPositions[0].asset;
       const fromToken = this.config.supportedPositions[1].asset;
@@ -322,7 +330,7 @@ export class AvnuAdapter extends BaseAdapter<DepositParams, WithdrawParams> {
         if (attempt === retries - 1) {
           throw err;
         }
-        await new Promise((resolve) => setTimeout(resolve, MAX_DELAY));
+        await new Promise((resolve) => setTimeout(resolve, MAX_AVNU_RETRY_DELAY));
       }
     }
     throw new Error("Failed to fetch quote after retries");

package/src/strategies/universal-adapters/index.ts

@@ -4,8 +4,7 @@ export * from "./vesu-adapter";
 export * from "./vesu-supply-only-adapter";
 export * from "./vesu-multiply-adapter";
 export * from "./vesu-modify-position-adapter";
-export * from "./extended-adapter";
 export * from "./adapter-utils";
 export * from "./token-transfer-adapter";
 export * from "./avnu-adapter";
-export * from "./svk-troves-adapter";
+export * from "./svk-troves-adapter";

package/src/strategies/universal-adapters/svk-troves-adapter.ts

@@ -41,6 +41,11 @@ export interface SvkTrovesAdapterConfig extends BaseAdapterConfig {
   positionOwner?: ContractAddr;
   /** Optional APY endpoint (defaults to {@link DEFAULT_TROVES_STRATEGIES_API}). */
   trovesStrategiesApiUrl?: string;
+  /**
+   * Optional redeem request NFT contract address. When provided, pending assets are calculated
+   * using `getPendingAssetsFromOwnerNFTMethod` instead of `due_assets_from_owner`.
+   */
+  redeemRequestNFT?: ContractAddr;
 }
 
 type TrovesStrategiesApiPayload = {
@@ -165,13 +170,21 @@ export class SvkTrovesAdapter extends BaseAdapter<DepositParams, WithdrawParams>
       const liquid = Web3Number.fromWei(liquidAssetsRaw.toString(), decimals);
 
       let pending = Web3Number.fromWei("0", decimals);
-      try {
-        const dueRaw: any = await vault.call("due_assets_from_owner", [owner.address]);
-        pending = Web3Number.fromWei(dueRaw.toString(), decimals);
-      } catch (e) {
-        logger.warn(
-          `${SvkTrovesAdapter.name}::getPosition: due_assets_from_owner failed (treating as 0): ${(e as Error).message}`,
+      if (this.config.redeemRequestNFT) {
+        pending = await this.getPendingAssetsFromOwnerNFTMethod(
+          this.config.redeemRequestNFT,
+          owner,
+          decimals,
         );
+      } else {
+        try {
+          const dueRaw: any = await vault.call("due_assets_from_owner", [owner.address]);
+          pending = Web3Number.fromWei(dueRaw.toString(), decimals);
+        } catch (e) {
+          logger.warn(
+            `${SvkTrovesAdapter.name}::getPosition: due_assets_from_owner failed (treating as 0): ${(e as Error).message}`,
+          );
+        }
       }
 
       const total = liquid.plus(pending);

package/src/strategies/universal-adapters/vesu-modify-position-adapter.ts

@@ -1,6 +1,7 @@
 import { ContractAddr, Web3Number } from "@/dataTypes";
 import { IProtocol, Protocols, TokenInfo } from "@/interfaces";
 import {
+  APYType,
   BaseAdapter,
   BaseAdapterConfig,
   ManageCall,
@@ -86,7 +87,10 @@ export class VesuModifyPositionAdapter extends BaseAdapter<
 
   private _getTargetHealthFactor(): number {
     if (this.config.targetLtv <= 0) {
-      return 1.0;
+      throw new Error(`Target LTV is less than or equal to 0: ${this.config.targetLtv}`);
+    }
+    if (this.config.targetLtv >= this._getEffectiveMaxLtv(this.config.maxLtv)) {
+      throw new Error(`Target LTV is greater than or equal to max LTV: ${this.config.targetLtv} >= ${this._getEffectiveMaxLtv(this.config.maxLtv)}`);
     }
     return this.config.maxLtv / this.config.targetLtv;
   }
@@ -330,11 +334,26 @@ export class VesuModifyPositionAdapter extends BaseAdapter<
   }
 
   async maxDeposit(amount?: Web3Number): Promise<PositionInfo> {
-    return getVesuCommonMaxDeposit(this._getPositionCommonContext(), amount);
+    const { collateralPosition, debtPosition: debtPosition } = await getVesuCommonMaxDeposit(this._getPositionCommonContext(), amount);
+    // since this is not multiply adapter, max allow collateral is directly max allowed deposit
+    const netAPY =
+    (collateralPosition.apy.apy * collateralPosition.usdValue - debtPosition.apy.apy * debtPosition.usdValue) /
+    (collateralPosition.usdValue - debtPosition.usdValue);
+    return {
+      ...collateralPosition,
+      apy: { apy: netAPY, type: APYType.BASE },
+    };
   }
 
   async maxWithdraw(): Promise<PositionInfo> {
-    return getVesuCommonMaxWithdraw(this._getPositionCommonContext());
+    const { collateralPosition, debtPosition } = await getVesuCommonMaxWithdraw(this._getPositionCommonContext());
+    const netAPY =
+    (collateralPosition.apy.apy * collateralPosition.usdValue - debtPosition.apy.apy * debtPosition.usdValue) /
+    (collateralPosition.usdValue - debtPosition.usdValue);
+    return {
+      ...collateralPosition,
+      apy: { apy: netAPY, type: APYType.BASE },
+    };
   }
 
   protected _getDepositLeaf(): {

package/src/strategies/universal-adapters/vesu-multiply-adapter.ts

@@ -16,6 +16,7 @@ import {
 import {
   SIMPLE_SANITIZER,
   SIMPLE_SANITIZER_V2,
+  SIMPLE_SANITIZER_VESU_V1_DELEGATIONS,
   toBigInt,
 } from "./adapter-utils";
 import { hash, uint256, Contract, CairoCustomEnum, num } from "starknet";
@@ -29,9 +30,7 @@ import {
 import { assert, logger } from "@/utils";
 import VesuMultiplyAbi from "@/data/vesu-multiple.abi.json";
 import { EkuboQuote, EkuboQuoter, TokenMarketData } from "@/modules";
-import { calculateDebtReductionAmountForWithdrawal } from "../vesu-extended-strategy/utils/helper";
 import { HealthFactorMath } from "@/utils/health-factor-math";
-import { MAX_LIQUIDATION_RATIO } from "../vesu-extended-strategy/utils/constants";
 import {
   VesuPositionCommonContext,
   getVesuCommonAPY,
@@ -139,7 +138,7 @@ export class VesuMultiplyAdapter extends BaseAdapter<
 
     const delegationOn: ManageCall = {
       proofReadableId: proofReadableIds.delegationOn,
-      sanitizer: isV2 ? SIMPLE_SANITIZER_V2 : SIMPLE_SANITIZER,
+      sanitizer: isV2 ? SIMPLE_SANITIZER_V2 : SIMPLE_SANITIZER_VESU_V1_DELEGATIONS,
       call: {
         contractAddress: vesuSingleton,
         selector: hash.getSelectorFromName("modify_delegation"),
@@ -151,7 +150,7 @@ export class VesuMultiplyAdapter extends BaseAdapter<
 
     const modifyLever: ManageCall = {
       proofReadableId: proofReadableIds.modifyLever,
-      sanitizer: isV2 ? SIMPLE_SANITIZER_V2 : SIMPLE_SANITIZER,
+      sanitizer: isV2 ? SIMPLE_SANITIZER_V2 : SIMPLE_SANITIZER_VESU_V1_DELEGATIONS,
       call: {
         contractAddress: vesuMultiply,
         selector: hash.getSelectorFromName("modify_lever"),
@@ -161,7 +160,7 @@ export class VesuMultiplyAdapter extends BaseAdapter<
 
     const delegationOff: ManageCall = {
       proofReadableId: proofReadableIds.delegationOff,
-      sanitizer: isV2 ? SIMPLE_SANITIZER_V2 : SIMPLE_SANITIZER,
+      sanitizer: isV2 ? SIMPLE_SANITIZER_V2 : SIMPLE_SANITIZER_VESU_V1_DELEGATIONS,
       call: {
         contractAddress: vesuSingleton,
         selector: hash.getSelectorFromName("modify_delegation"),
@@ -178,7 +177,8 @@ export class VesuMultiplyAdapter extends BaseAdapter<
     const collateral = this.config.collateral;
     const debt = this.config.debt;
     return {
-      approve: `amc_${this.config.poolId.shortString()}_${collateral.symbol}_${debt.symbol}`,
+      approve_collateral: `amc_${this.config.poolId.shortString()}_${collateral.symbol}`,
+      approve_margin: `amc_${this.config.poolId.shortString()}_${this.config.marginToken.symbol}`,
       delegationOn: `sd1_${this.config.poolId.shortString()}_${collateral.symbol}_${debt.symbol}`,
       modifyLever: `vm_${this.config.poolId.shortString()}_${collateral.symbol}_${debt.symbol}`,
       delegationOff: `sd2_${this.config.poolId.shortString()}_${collateral.symbol}_${debt.symbol}`,
@@ -321,7 +321,13 @@ export class VesuMultiplyAdapter extends BaseAdapter<
     const numeratorPart2 = existingDebt
       .multipliedBy(debtPrice)
       .multipliedBy(this.config.targetHealthFactor);
+    if (dexPrice === 0) {
+      throw new Error("_computeTargetDebtDelta::dexPrice is 0");
+    }
     const denominatorPart = this.config.targetHealthFactor - ltv / dexPrice;
+    if (denominatorPart === 0) {
+      throw new Error("_computeTargetDebtDelta::denominatorPart is 0");
+    }
     const x_debt_usd = numeratorPart1
       .minus(numeratorPart2)
       .dividedBy(denominatorPart);
@@ -377,30 +383,42 @@ export class VesuMultiplyAdapter extends BaseAdapter<
     return 0;
   }
 
-  async maxDeposit(amount?: Web3Number): Promise<PositionInfo> {
-    // always add vesu modify position adapter, which shall
-    // return correct max deposit
+  private _computeMax(collateralPosition: PositionInfo, debtPosition: PositionInfo): PositionInfo {
+    // in multiply, most of the debt also goes as collateral. hence, net addable is collateral - debt.
+    if (collateralPosition.usdValue <= 0 || collateralPosition.usdValue <= debtPosition.usdValue) {
+      return {
+        tokenInfo: this.config.collateral,
+        amount: new Web3Number(0, this.config.collateral.decimals),
+        usdValue: 0,
+        remarks: "Max deposit",
+        apy: { apy: 0, type: APYType.BASE },
+        protocol: this.protocol,
+      };
+    }
+    const maxCollateralUsd = collateralPosition.usdValue - debtPosition.usdValue;
+    const collateralPrice = collateralPosition.usdValue / collateralPosition.amount.toNumber();
+    const collateralAmount = new Web3Number(maxCollateralUsd / collateralPrice, this.config.collateral.decimals);
+    const netAPY =
+    (collateralPosition.apy.apy * collateralPosition.usdValue - debtPosition.apy.apy * debtPosition.usdValue) /
+    (maxCollateralUsd);
     return {
-      tokenInfo: this.config.baseToken,
-      amount: new Web3Number(0, this.config.baseToken.decimals),
-      usdValue: 0,
+      tokenInfo: this.config.collateral,
+      amount: collateralAmount,
+      usdValue: maxCollateralUsd,
       remarks: "Max deposit",
-      apy: { apy: 0, type: APYType.BASE },
+      apy: { apy: netAPY, type: APYType.BASE },
       protocol: this.protocol,
-    }
+    };
+  }
+
+  async maxDeposit(amount?: Web3Number): Promise<PositionInfo> {
+    const { collateralPosition, debtPosition: debtPosition } = await getVesuCommonMaxDeposit(this._getPositionCommonContext(), amount);
+    return this._computeMax(collateralPosition, debtPosition);
   }
 
   async maxWithdraw(): Promise<PositionInfo> {
-    // always add vesu modify position adapter, which shall
-    // return correct max withdraw
-    return {
-      tokenInfo: this.config.baseToken,
-      amount: new Web3Number(0, this.config.baseToken.decimals),
-      usdValue: 0,
-      remarks: "Max withdraw",
-      apy: { apy: 0, type: APYType.BASE },
-      protocol: this.protocol,
-    }
+    const { collateralPosition, debtPosition } = await getVesuCommonMaxWithdraw(this._getPositionCommonContext());
+    return this._computeMax(collateralPosition, debtPosition);
   }
 
   // ─── Leaf Configuration ────────────────────────────────────────────────────
@@ -415,20 +433,27 @@ export class VesuMultiplyAdapter extends BaseAdapter<
     const collateral = this.config.collateral;
     const debt = this.config.debt;
     const { vesuMultiply, vesuSingleton, isV2 } = this._getMultiplyContract();
-    const token = debt;
-    const idSuffix = `${collateral.symbol}_${debt.symbol}`;
     const idApprovePrefix = "amc";
     const idDelegOnPrefix = "sd1";
     const idMultiplyPrefix = "vm";
     const idDelegOffPrefix = "sd2";
 
     return [
+      // allow approval of margin token and collateral to vesu multiply contract
+      // depending on strategy, respective token needs to be approved by implementer
       {
-        target: token.address,
+        target: this.config.marginToken.address,
         method: "approve",
         packedArguments: [vesuMultiply.toBigInt()],
         sanitizer: SIMPLE_SANITIZER,
-        id: `${idApprovePrefix}_${this.config.poolId.shortString()}_${idSuffix}`,
+        id: `${idApprovePrefix}_${this.config.poolId.shortString()}_${this.config.marginToken.symbol}`,
+      },
+      {
+        target: collateral.address,
+        method: "approve",
+        packedArguments: [vesuMultiply.toBigInt()],
+        sanitizer: SIMPLE_SANITIZER,
+        id: `${idApprovePrefix}_${this.config.poolId.shortString()}_${collateral.symbol}`,
       },
       {
         target: vesuSingleton,
@@ -436,7 +461,7 @@ export class VesuMultiplyAdapter extends BaseAdapter<
         packedArguments: isV2
           ? [vesuMultiply.toBigInt()]
           : [this.config.poolId.toBigInt(), vesuMultiply.toBigInt()],
-        sanitizer: isV2 ? SIMPLE_SANITIZER_V2 : SIMPLE_SANITIZER,
+        sanitizer: isV2 ? SIMPLE_SANITIZER_V2 : SIMPLE_SANITIZER_VESU_V1_DELEGATIONS,
         id: `${idDelegOnPrefix}_${this.config.poolId.shortString()}_${collateral.symbol}_${debt.symbol}`,
       },
       {
@@ -457,7 +482,7 @@ export class VesuMultiplyAdapter extends BaseAdapter<
         packedArguments: isV2
           ? [vesuMultiply.toBigInt()]
           : [this.config.poolId.toBigInt(), vesuMultiply.toBigInt()],
-        sanitizer: isV2 ? SIMPLE_SANITIZER_V2 : SIMPLE_SANITIZER,
+        sanitizer: isV2 ? SIMPLE_SANITIZER_V2 : SIMPLE_SANITIZER_VESU_V1_DELEGATIONS,
         id: `${idDelegOffPrefix}_${this.config.poolId.shortString()}_${collateral.symbol}_${debt.symbol}`,
       },
     ];
@@ -481,7 +506,7 @@ export class VesuMultiplyAdapter extends BaseAdapter<
         packedArguments: isV2
           ? [vesuMultiply.toBigInt()]
           : [this.config.poolId.toBigInt(), vesuMultiply.toBigInt()],
-        sanitizer: isV2 ? SIMPLE_SANITIZER_V2 : SIMPLE_SANITIZER,
+        sanitizer: isV2 ? SIMPLE_SANITIZER_V2 : SIMPLE_SANITIZER_VESU_V1_DELEGATIONS,
         id: `sdow_${this.config.poolId.shortString()}_${collateral.symbol}_${debt.symbol}`,
       },
       {
@@ -493,7 +518,7 @@ export class VesuMultiplyAdapter extends BaseAdapter<
           this.config.debt.address.toBigInt(),
           this.config.vaultAllocator.toBigInt(),
         ],
-        sanitizer: isV2 ? SIMPLE_SANITIZER_V2 : SIMPLE_SANITIZER,
+        sanitizer: isV2 ? SIMPLE_SANITIZER_V2 : SIMPLE_SANITIZER_VESU_V1_DELEGATIONS,
         id: `vmw_${this.config.poolId.shortString()}_${collateral.symbol}_${debt.symbol}`,
       },
       {
@@ -502,7 +527,7 @@ export class VesuMultiplyAdapter extends BaseAdapter<
         packedArguments: isV2
           ? [vesuMultiply.toBigInt()]
           : [this.config.poolId.toBigInt(), vesuMultiply.toBigInt()],
-        sanitizer: isV2 ? SIMPLE_SANITIZER_V2 : SIMPLE_SANITIZER,
+        sanitizer: isV2 ? SIMPLE_SANITIZER_V2 : SIMPLE_SANITIZER_VESU_V1_DELEGATIONS,
         id: `sdofw_${this.config.poolId.shortString()}_${collateral.symbol}_${debt.symbol}`,
       },
     ];
@@ -557,7 +582,7 @@ export class VesuMultiplyAdapter extends BaseAdapter<
     const uint256Amount = uint256.bnToUint256(approveAmount.toWei());
 
     const approveCall: ManageCall = {
-      proofReadableId: proofReadableIds.approve,
+      proofReadableId: approveToken.address.eq(this.config.collateral.address) ? proofReadableIds.approve_collateral : proofReadableIds.approve_margin,
       sanitizer: SIMPLE_SANITIZER,
       call: {
         contractAddress: approveToken.address,
@@ -699,11 +724,6 @@ export class VesuMultiplyAdapter extends BaseAdapter<
     let leverSwap: Swap[] = [];
     let leverSwapLimitAmount = Web3Number.fromWei(0, debtToken.decimals);
 
-    const isIncrease = debtAmount.greaterThanOrEqualTo(0);
-    if (!isIncrease && debtAmount.greaterThan(0)) {
-      debtAmount = Web3Number.fromWei(0, this.config.debt.decimals);
-    }
-
     if (!debtAmount.isZero() && debtAmount.greaterThan(0)) {
       try {
         let swapQuote: EkuboQuote;
@@ -914,10 +934,7 @@ export class VesuMultiplyAdapter extends BaseAdapter<
         throw new Error(`VesuMultiplyAdapter: Lever swap price impact too high (${leverSwapQuote.price_impact})`);
       }
 
-      leverCollateralUsed = Web3Number.fromWei(
-        leverSwapQuote.total_calculated,
-        collateralToken.decimals
-      ).abs();
+      leverCollateralUsed = collateralToSwap;
     }
 
     let withdrawSwap: Swap[] = [];
@@ -962,6 +979,8 @@ export class VesuMultiplyAdapter extends BaseAdapter<
           estimatedOutput.decimals = params.outputToken.decimals;
           withdrawSwapLimitAmount = estimatedOutput
             .multipliedBy(1 - this.maxSlippage);
+        } else {
+          throw new Error(`VesuMultiplyAdapter: Withdraw swap price impact too high (${withdrawQuote.price_impact})`);
         }
       }
     }
@@ -1029,24 +1048,27 @@ export class VesuMultiplyAdapter extends BaseAdapter<
     );
     const debtPrice = await this.config.pricer.getPrice(debtToken.symbol);
 
+    const maxLTV = await this._vesuAdapter.getLTVConfig(
+      this.config.networkConfig
+    );
+
     const { deltadebtAmountUnits: debtAmountToRepay } =
-      calculateDebtReductionAmountForWithdrawal(
+      HealthFactorMath.calculateDebtReductionAmountForWithdrawal(
         existingDebtInfo.amount,
         existingCollateralInfo.amount,
-        MAX_LIQUIDATION_RATIO,
+        maxLTV,
+        this.config.targetHealthFactor,
         params.amount,
         collateralPrice.price,
         debtPrice.price,
-        debtToken.decimals
+        collateralToken,
+        debtToken
       );
     if (!debtAmountToRepay) {
       throw new Error("error calculating debt amount to repay");
     }
 
-    const debtToRepayAbs = new Web3Number(
-      debtAmountToRepay,
-      debtToken.decimals
-    ).abs();
+    const debtToRepayAbs = debtAmountToRepay.abs();
     const existingDebtAbs = existingDebtInfo.amount.abs();
 
     const shouldCloseByDebt = debtToRepayAbs.greaterThanOrEqualTo(existingDebtAbs);
@@ -1155,7 +1177,7 @@ export class VesuMultiplyAdapter extends BaseAdapter<
                 sqrt_ratio_limit: uint256.bnToUint256(
                   route.sqrt_ratio_limit.toWei()
                 ),
-                skip_ahead: BigInt(0),
+                skip_ahead: BigInt(100),
               })),
               token_amount: {
                 token: swap.token_amount.token.toBigInt(),
@@ -1254,12 +1276,13 @@ export class VesuMultiplyAdapter extends BaseAdapter<
     );
     const allZero = positions.every((p) => p.usdValue === 0);
 
-    if (allZero) {
+    if (allZero && positions.length == 2) {
       const collateralUSD = 1000;
       const maxLTV = await this._vesuAdapter.getLTVConfig(
         this.config.networkConfig
       );
       const targetHF = this.config.targetHealthFactor;
+      // though we are passing in token terms, but by simulating with price 1,  usd terms == token terms
       const maxDebt = HealthFactorMath.getMaxDebtAmountOnLooping(
         new Web3Number(collateralUSD, this.config.collateral.decimals),
         1,

package/src/strategies/universal-adapters/vesu-position-common.ts

@@ -113,7 +113,7 @@ export async function getVesuCommonPosition(
       position.amount = position.amount.multipliedBy(-1);
       position.usdValue = position.usdValue * -1;
     }
-    const result = { amount: position.amount, remarks: supportedPosition.isDebt ? "Vesu debt" : "Vesu collateral" };
+    const result = { amount: position.amount, remarks: position.remarks };
     ctx.setCache(cacheKey, result, 60000);
     return result;
   } catch (error) {
@@ -132,10 +132,11 @@ export async function getVesuCommonMaxBorrowableAPY(
   return collateralAPY.apy * 0.8;
 }
 
+/// @dev this function is used to calculate the max deposit amount based on the available debt capacity
 export async function getVesuCommonMaxDeposit(
   ctx: VesuPositionCommonContext,
   amount?: Web3Number,
-): Promise<PositionInfo> {
+): Promise<{collateralPosition: PositionInfo, debtPosition: PositionInfo}> {
   const collateral = ctx.collateral;
   const debt = ctx.debt;
   try {
@@ -169,15 +170,20 @@ export async function getVesuCommonMaxDeposit(
       throw new Error("Debt price is 0");
     }
 
-    const maxCollateralFromDebt = HealthFactorMath.getMinCollateralRequiredOnLooping(
-      actualMaxBorrowable,
+    /**
+     * We use existing collateral and debt also in the calculations.
+     * This will ensure any new collateral requirement also considers low ltv possibilities + new debt being created.
+     */
+    const maxCollateralFromDebt = HealthFactorMath.getCollateralRequired(
+      actualMaxBorrowable.plus(debtPosition.amount), // net new debt
       debtPrice.price,
       ctx.targetHealthFactor,
       maxLTV,
       collateralPrice.price,
       collateral,
     );
-    const maxDepositAmount = amount ? amount.minimum(maxCollateralFromDebt) : maxCollateralFromDebt;
+    const maxNewCollateral = maxCollateralFromDebt.minus(collateralPosition.amount).minimum(0); // net new collateral
+    const maxDepositAmount = amount ? amount.minimum(maxNewCollateral) : maxNewCollateral;
     const usdValue = await ctx.getUSDValue(collateral, maxDepositAmount);
     const apys = await Promise.all([
       getVesuCommonAPY(ctx, { asset: collateral, isDebt: false }),
@@ -185,19 +191,22 @@ export async function getVesuCommonMaxDeposit(
     ]);
 
     const borrowAmountUSD = actualMaxBorrowable.multipliedBy(debtPrice.price);
-    const netCollateralUSD = usdValue + borrowAmountUSD.toNumber();
-    const netAPY =
-      (apys[0].apy * netCollateralUSD + apys[1].apy * borrowAmountUSD.toNumber()) /
-      usdValue;
 
-    return {
+    return {collateralPosition: {
       tokenInfo: collateral,
       amount: maxDepositAmount,
       usdValue,
       remarks: "Max deposit based on available debt capacity",
-      apy: { apy: netAPY, type: APYType.BASE },
+      apy: { apy: apys[0].apy, type: APYType.BASE },
       protocol: ctx.protocol,
-    };
+    }, debtPosition: {
+      tokenInfo: debt,
+      amount: actualMaxBorrowable,
+      usdValue: borrowAmountUSD.toNumber(),
+      remarks: "Max borrow based on available debt capacity",
+      apy: { apy: apys[1].apy, type: APYType.BASE },
+      protocol: ctx.protocol,
+    }};
   } catch (error) {
     logger.error(`${ctx.adapterName}: Error calculating max deposit:`, error);
     throw error;
@@ -206,7 +215,7 @@ export async function getVesuCommonMaxDeposit(
 
 export async function getVesuCommonMaxWithdraw(
   ctx: VesuPositionCommonContext,
-): Promise<PositionInfo> {
+): Promise<{collateralPosition: PositionInfo, debtPosition: PositionInfo}> {
   const collateral = ctx.collateral;
   const debt = ctx.debt;
   try {
@@ -219,30 +228,28 @@ export async function getVesuCommonMaxWithdraw(
       throw new Error("Could not find current positions");
     }
 
-    const collateralPrice = collateralPosition.usdValue / collateralPosition.amount.toNumber();
-    const debtInCollateral = debtPosition.usdValue / collateralPrice;
-    const maxWithdrawable = collateralPosition.amount.minus(debtInCollateral);
-    const result = maxWithdrawable.greaterThan(0)
-      ? maxWithdrawable
-      : new Web3Number("0", collateral.decimals);
-    const usdValue = await ctx.getUSDValue(collateral, result);
-    const debtUSD = debtPosition.usdValue;
     const apys = await Promise.all([
       getVesuCommonAPY(ctx, { asset: collateral, isDebt: false }),
       getVesuCommonAPY(ctx, { asset: debt, isDebt: true }),
     ]);
-    const netAPY =
-      usdValue - debtUSD > 0
-        ? (apys[0].apy * usdValue + apys[1].apy * debtUSD) / (usdValue - debtUSD)
-        : 0;
 
     return {
-      tokenInfo: collateral,
-      amount: result,
-      usdValue,
-      remarks: "Max withdraw based on health factor",
-      apy: { apy: netAPY, type: APYType.BASE },
-      protocol: ctx.protocol,
+      collateralPosition: {
+        tokenInfo: collateral,
+        amount: collateralPosition.amount,
+        usdValue: collateralPosition.usdValue,
+        remarks: "Max withdraw based on health factor",
+        apy: { apy: apys[0].apy, type: APYType.BASE },
+        protocol: ctx.protocol,
+      },
+      debtPosition: {
+        tokenInfo: debt,
+        amount: debtPosition.amount,
+        usdValue: debtPosition.usdValue,
+        remarks: "Max withdraw based on health factor",
+        apy: { apy: apys[1].apy, type: APYType.BASE },
+        protocol: ctx.protocol,
+      },
     };
   } catch (error) {
     logger.error(`${ctx.adapterName}: Error calculating max withdraw:`, error);