@strkfarm/sdk 2.0.0-dev.17 → 2.0.0-dev.18

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

@@ -54,7 +54,7 @@ import {
 } from "./utils/helper";
 import { SingleTokenInfo } from "../base-strategy";
 import { Call } from "starknet";
-import { PositionTypeAvnuExtended} from "../universal-strategy";
+import { PositionTypeAvnuExtended } from "../universal-strategy";
 import { TransactionMetadata, TransactionResult } from "./types/transaction-metadata";
 
 
@@ -67,6 +67,7 @@ export interface VesuExtendedStrategySettings
   minHealthFactor: number;
   aumOracle: ContractAddr;
   minimumWBTCDifferenceForAvnuSwap: number;
+  walletAddress: string;
 }
 
 export class VesuExtendedMultiplierStrategy<
@@ -182,7 +183,7 @@ export class VesuExtendedMultiplierStrategy<
   }
 
   async moveAssetsToVaultAllocator(amount: Web3Number, extendedAdapter: ExtendedAdapter): Promise<{
-    calls:Call[],
+    calls: Call[],
     status: boolean,
   }> {
     try {
@@ -234,7 +235,7 @@ export class VesuExtendedMultiplierStrategy<
       const vesuAdapter = await this.getVesuAdapter();
       const extendedAdapter = await this.getExtendedAdapter();
       logger.info(`${VesuExtendedMultiplierStrategy.name}::shouldInvest adapters fetched: vesuAdapter=${!!vesuAdapter}, extendedAdapter=${!!extendedAdapter}, extendedAdapter.client=${!!extendedAdapter?.client}`);
-      
+
       if (!vesuAdapter) {
         logger.error(
           `Vesu adapter not configured in metadata. This is a configuration issue, not a temporary failure.`
@@ -277,10 +278,10 @@ export class VesuExtendedMultiplierStrategy<
           vesuLeverage: 0,
         };
       }
-      
+
       logger.info(`${VesuExtendedMultiplierStrategy.name}::shouldInvest calling getUnusedBalance`);
       const balance = await this.getUnusedBalance();
-      
+
       if (!Number.isFinite(balance.usdValue) || balance.usdValue < 0) {
         logger.error(
           `Invalid balance.usdValue: ${balance.usdValue}. Expected a finite, non-negative number.`
@@ -297,7 +298,7 @@ export class VesuExtendedMultiplierStrategy<
       }
       logger.info(`${VesuExtendedMultiplierStrategy.name}::shouldInvest balance: ${balance.usdValue}`);
       const usdcBalanceOnExtended = await extendedAdapter.getExtendedDepositAmount();
-      
+
       if (usdcBalanceOnExtended) {
         const availableForWithdrawal = parseFloat(usdcBalanceOnExtended.availableForWithdrawal);
         if (!Number.isFinite(availableForWithdrawal) || availableForWithdrawal < 0) {
@@ -315,11 +316,11 @@ export class VesuExtendedMultiplierStrategy<
           };
         }
       }
-      
+
       /** The LIMIT_BALANCE is the bffer amount to keep in the investing Cycle */
       const amountToInvest = new Web3Number(balance.usdValue, USDC_TOKEN_DECIMALS).plus(usdcBalanceOnExtended?.availableForWithdrawal ?? 0).multipliedBy(1 - LIMIT_BALANCE);
 
-      
+
       const amountToInvestNumber = amountToInvest.toNumber();
       if (!Number.isFinite(amountToInvestNumber)) {
         logger.error(
@@ -335,7 +336,7 @@ export class VesuExtendedMultiplierStrategy<
           vesuLeverage: 0,
         };
       }
-      
+
       logger.info(`${VesuExtendedMultiplierStrategy.name}::shouldInvest amountToInvest: ${amountToInvestNumber}`);
       if (amountToInvest.lessThan(LIMIT_BALANCE_VALUE)) {
         return {
@@ -369,7 +370,7 @@ export class VesuExtendedMultiplierStrategy<
         collateralPrice,
         debtPrice
       } = await this.getAssetPrices();
-      
+
 
       if (!Number.isFinite(collateralPrice.price) || collateralPrice.price <= 0) {
         logger.error(
@@ -399,7 +400,7 @@ export class VesuExtendedMultiplierStrategy<
           vesuLeverage: 0,
         };
       }
-      
+
       const { vesu_amount, extended_amount, extended_leverage, vesu_leverage } =
         await calculateAmountDistribution(
           amountToInvest.toNumber(),
@@ -482,35 +483,35 @@ export class VesuExtendedMultiplierStrategy<
       if (extendedAmount.isNegative() && extendedAmount.abs().greaterThan(extendedAdapter.minimumExtendedMovementAmount)) {
         totalExtendedWithdrawal = totalExtendedWithdrawal.plus(extendedAmount.abs());
       }
-      
+
       // Calculate remaining Extended difference (target vs current)
       // If extendedAmount was negative, we've already accounted for that withdrawal
       // So we calculate based on what Extended will be after that withdrawal
       const extendedTargetAmount = extendedAmount.abs(); // Use absolute value as target
       let projectedExtendedBalance = usdcAmountOnExtendedAvailableForWithdrawal;
-      
+
       if (extendedAmount.isNegative()) {
         projectedExtendedBalance = projectedExtendedBalance - extendedAmount.abs().toNumber();
       }
-      
+
       const extendedAmountDifference = extendedTargetAmount.minus(projectedExtendedBalance);
       const extendedAmountDifferenceAbs = extendedAmountDifference.abs();
-      
+
       // Track additional Extended movements
       if (extendedAmountDifference.lessThan(0)) {
         totalExtendedWithdrawal = totalExtendedWithdrawal.plus(extendedAmountDifferenceAbs);
       } else if (extendedAmountDifference.greaterThan(0)) {
         totalExtendedDeposit = totalExtendedDeposit.plus(extendedAmountDifference);
       }
-    
+
       const vesuTargetAmount = vesuAmount.abs();
       const projectedWalletBalance = usdcAmountInWallet
         .plus(totalExtendedWithdrawal)
         .minus(totalExtendedDeposit);
-      
+
       let vesuAmountDifference = vesuTargetAmount.minus(projectedWalletBalance);
       const vesuAmountDifferenceAbs = vesuAmountDifference.abs();
-      
+
       logger.info(`${VesuExtendedMultiplierStrategy.name}::shouldMoveAssets calculated movements - Extended withdrawal: ${totalExtendedWithdrawal.toNumber()}, Extended deposit: ${totalExtendedDeposit.toNumber()}, Extended diff: ${extendedAmountDifference.toNumber()}, Projected wallet: ${projectedWalletBalance.toNumber()}, Vesu diff: ${vesuAmountDifference.toNumber()}`);
       let calls: Call[] = [];
       let transactionResults: TransactionResult[] = [];
@@ -634,7 +635,7 @@ export class VesuExtendedMultiplierStrategy<
           }
         }
       }
-      
+
       // Handle Vesu adjustments based on calculated difference (already adjusted for Extended movements)
       if (vesuAmountDifferenceAbs.greaterThan(vesuAdapter.minimumVesuMovementAmount)) {
         if (vesuAmountDifference.lessThanOrEqualTo(0)) {
@@ -672,7 +673,7 @@ export class VesuExtendedMultiplierStrategy<
           }
         }
       }
-      
+
       return transactionResults;
     } catch (err) {
       logger.error(`Failed moving assets to vesu: ${err}`);
@@ -808,10 +809,10 @@ export class VesuExtendedMultiplierStrategy<
           receivedTxnHash: withdrawalFromExtendedTxnHash,
         } =
           await extendedAdapter.withdrawFromExtended(params.amount);
-          /**
-           * This logic needs fixing
-           */
-          logger.info(`withdrawalFromExtendedStatus: ${withdrawalFromExtendedStatus}, withdrawalFromExtendedTxnHash: ${withdrawalFromExtendedTxnHash}`);
+        /**
+         * This logic needs fixing
+         */
+        logger.info(`withdrawalFromExtendedStatus: ${withdrawalFromExtendedStatus}, withdrawalFromExtendedTxnHash: ${withdrawalFromExtendedTxnHash}`);
         if (withdrawalFromExtendedStatus && withdrawalFromExtendedTxnHash) {
           /**
           * We need to move assets from my wallet back to vault contract
@@ -819,10 +820,10 @@ export class VesuExtendedMultiplierStrategy<
           const extendedHoldings = await extendedAdapter.getExtendedDepositAmount();
           logger.info(`extendedHoldings after withdrawal ${extendedHoldings?.availableForWithdrawal}`);
           await new Promise(resolve => setTimeout(resolve, 5000));
-          const {calls, status} = await this.moveAssetsToVaultAllocator(params.amount, extendedAdapter);
+          const { calls, status } = await this.moveAssetsToVaultAllocator(params.amount, extendedAdapter);
           if (calls.length > 0 && status) {
             return this.createTransactionResult(calls, true, params, "WITHDRAWAL", params.cycleType);
-          }else {
+          } else {
             /**
              * This is a fallback scenario, where the funds were withdrawn from extended, but didn't get transferred to the wallet
              * We need to return a successful transaction result, but with no calls
@@ -830,7 +831,7 @@ export class VesuExtendedMultiplierStrategy<
              */
             return this.createTransactionResult([], true, params, "WITHDRAWAL", params.cycleType);
           }
-        }else if(withdrawalFromExtendedStatus && !withdrawalFromExtendedTxnHash){
+        } else if (withdrawalFromExtendedStatus && !withdrawalFromExtendedTxnHash) {
           logger.error("withdrawal from extended successful, but funds didn't get transferred to the wallet");
           return this.createTransactionResult([], true, params, "WITHDRAWAL", params.cycleType);
         } else {
@@ -906,7 +907,7 @@ export class VesuExtendedMultiplierStrategy<
       return this.createTransactionResult([], false, params, "NONE", params.cycleType);
     } catch (err) {
       logger.error(`error moving assets: ${err}`);
-      return this.createTransactionResult([], false, params,"NONE", params.cycleType);
+      return this.createTransactionResult([], false, params, "NONE", params.cycleType);
     }
   }
 
@@ -938,7 +939,7 @@ export class VesuExtendedMultiplierStrategy<
     const price = ask.plus(bid).dividedBy(2);
     const btcToken = vesuAdapter.config.supportedPositions[0].asset;
     const btcPriceAvnu = await avnuAdapter.getPriceOfToken(btcToken.address.toString());
-    
+
     if (!btcPriceAvnu) {
       logger.error(`error getting btc price avnu: ${btcPriceAvnu}`);
       return false;
@@ -947,15 +948,15 @@ export class VesuExtendedMultiplierStrategy<
     logger.info(`btcPriceAvnu: ${btcPriceAvnu}`);
     const priceDifference = new Web3Number(price.minus(btcPriceAvnu).toFixed(2), 0);
     logger.info(`priceDifference: ${priceDifference}`);
-    if(priceDifference.isNegative()){
+    if (priceDifference.isNegative()) {
       return false;
     }
-    if(positionType === PositionTypeAvnuExtended.OPEN){
+    if (positionType === PositionTypeAvnuExtended.OPEN) {
       logger.info(`price difference between avnu and extended for open position: ${priceDifference.toNumber()}, minimumExtendedPriceDifferenceForSwapOpen: ${avnuAdapter.config.minimumExtendedPriceDifferenceForSwapOpen}`);
       const result = priceDifference.greaterThanOrEqualTo(avnuAdapter.config.minimumExtendedPriceDifferenceForSwapOpen); // 500 for now
       logger.info(`result: ${result}`);
       return result;
-    }else{
+    } else {
       logger.info(`price difference between avnu and extended for close position: ${priceDifference.toNumber()}, maximumExtendedPriceDifferenceForSwapClosing: ${avnuAdapter.config.maximumExtendedPriceDifferenceForSwapClosing}`);
       const result = priceDifference.lessThanOrEqualTo(avnuAdapter.config.maximumExtendedPriceDifferenceForSwapClosing); // 1000 for now
       logger.info(`result: ${result}`);
@@ -1127,7 +1128,7 @@ export class VesuExtendedMultiplierStrategy<
       }, prevAum: prevAum, splits: [realAUM, estimatedAUMDelta]
     };
   }
-  
+
   async processTransactionDataFromSDK(txnData: TransactionResult<any>[]): Promise<{ callsToBeExecutedFinal: Call[], txnMetadata: TransactionMetadata[] } | null> {
     try {
       const txnsToBeExecuted = txnData.filter(txn => {
@@ -1160,6 +1161,155 @@ export class VesuExtendedMultiplierStrategy<
       return null;
     }
   }
+
+  async getMaxBorrowableAmount(): Promise<Web3Number> {
+    const vesuAdapter = await this.getVesuAdapter();
+    const extendedAdapter = await this.getExtendedAdapter();
+    if (!vesuAdapter || !extendedAdapter) {
+      return new Web3Number(0, 0);
+    }
+    const extendedFundingRate = new Web3Number((await extendedAdapter.getNetAPY()).toFixed(4), 0);
+    const extendedPositions = await extendedAdapter.getAllOpenPositions();
+    if (!extendedPositions || extendedPositions.length === 0) {
+      logger.info(`no extended positions found`);
+      return new Web3Number(0, 0);
+    }
+    const extendePositionSizeUSD = new Web3Number(extendedPositions[0].value || 0, 0);
+    const vesuPositions = await vesuAdapter.getPositions();
+    const vesuSupplyApy = vesuPositions[0].apy.apy;
+    const vesuCollateralSizeUSD = new Web3Number(vesuPositions[0].usdValue.toFixed(USDC_TOKEN_DECIMALS), USDC_TOKEN_DECIMALS);
+    const vesuDebtSizeUSD = new Web3Number(vesuPositions[1].usdValue.toFixed(USDC_TOKEN_DECIMALS), USDC_TOKEN_DECIMALS)
+     const num1 = extendePositionSizeUSD.multipliedBy(extendedFundingRate);
+    const num2 = vesuCollateralSizeUSD.multipliedBy(vesuSupplyApy);
+    const num3 = vesuDebtSizeUSD.abs()
+    const maxBorrowApy = num1.plus(num2).minus(0.1).dividedBy(num3);
+    const vesuMaxBorrowableAmount = await vesuAdapter.vesuAdapter.getMaxBorrowableByInterestRate(this.config, vesuAdapter.config.debt, maxBorrowApy.toNumber());
+    return new Web3Number(vesuMaxBorrowableAmount.toFixed(USDC_TOKEN_DECIMALS), USDC_TOKEN_DECIMALS);
+  }
+
+  async getVesuHealthFactors(): Promise<number[]> {
+    const vesuAdapter = await this.getVesuAdapter();
+    const extendedAdapter = await this.getExtendedAdapter();
+    if (!vesuAdapter || !extendedAdapter) {
+      return [0, 0];
+    }
+    const vesuPositions = await vesuAdapter.getPositions();
+    const vesuCollateralSizeUSD = new Web3Number(vesuPositions[0].usdValue.toFixed(USDC_TOKEN_DECIMALS), 0);
+    const vesuDebtSizeUSD = new Web3Number(vesuPositions[1].usdValue.toFixed(USDC_TOKEN_DECIMALS), 0);
+    const actualLtv = vesuDebtSizeUSD.dividedBy(vesuCollateralSizeUSD).abs();
+    logger.info(`actualLtv: ${actualLtv.toNumber()}`);
+    const maxLtv = new Web3Number(await vesuAdapter.vesuAdapter.getLTVConfig(this.config), 4);
+    const healthFactor = new Web3Number(maxLtv.dividedBy(actualLtv).toFixed(4), 4);
+    logger.info(`healthFactor: ${healthFactor.toNumber()}`);
+    const extendedBalance = await extendedAdapter.getExtendedDepositAmount();
+    if (!extendedBalance) {
+      return [0, 0];
+    }
+    const extendedLeverage = new Web3Number((Number(extendedBalance.marginRatio) * 100).toFixed(4), 4);
+    logger.info(`extendedLeverage: ${extendedLeverage.toNumber()}`);
+    return [healthFactor.toNumber(), extendedLeverage.toNumber()];
+  }
+
+  async netAPY(): Promise<{ net: number; splits: { apy: number; id: string; }[]; }> {
+    const allPositions: PositionInfo[] = [];
+    for (let adapter of this.metadata.additionalInfo.adapters) {
+        if(adapter.adapter.name !== ExtendedAdapter.name){
+          let positions = await adapter.adapter.getPositions();
+          if(positions.length > 0){
+            allPositions.push(...positions);
+          }
+        }
+      }
+    const extendedAdapter =await this.getExtendedAdapter()
+    if(!extendedAdapter){
+      return {
+        net: 0,
+        splits: []
+      }
+    }
+    let vesuPositions = allPositions.filter((item) => item.protocol === Protocols.VESU);
+    vesuPositions.map((item) =>{
+      item.apy.apy = item.apy.apy * 0.1;
+    })
+    const extendedPositions = await extendedAdapter.getAllOpenPositions();
+    const usdcToken = Global.getDefaultTokens().find(token => token.symbol === "USDC");
+    if(!extendedPositions || !usdcToken){
+      return {
+        net: 0,
+        splits: []
+      }
+    }
+    const extendedPosition = extendedPositions[0] || 0;
+    const extendedEquity = (await extendedAdapter.getExtendedDepositAmount())?.equity || 0;
+    const extendedApy = await extendedAdapter.getNetAPY();
+    const totalHoldingsUSDValue = allPositions.reduce((acc, curr) => acc + curr.usdValue, 0) + Number(extendedEquity);
+    console.log(totalHoldingsUSDValue)
+    const extendedPositionSizeMultipliedByApy = Number(extendedPosition.value) * extendedApy;
+    let weightedAPYs = allPositions.reduce((acc, curr) => acc + curr.apy.apy * curr.usdValue, 0) + extendedPositionSizeMultipliedByApy;
+    console.log(weightedAPYs)
+    const netAPY = weightedAPYs / totalHoldingsUSDValue;
+    console.log(netAPY)
+    allPositions.push({
+      tokenInfo: usdcToken,
+      amount: new Web3Number(extendedPosition.size, 0),
+      usdValue: Number(extendedEquity),
+      apy: { apy: extendedApy, type: APYType.BASE },
+      remarks: AUMTypes.FINALISED,
+      protocol: Protocols.EXTENDED 
+    })
+    return {
+      net: netAPY,
+      splits: allPositions.map(p => ({apy: p.apy.apy, id: p.remarks ?? ''}))
+    };
+  }
+
+  async getWalletHoldings(): Promise<{
+    tokenInfo: TokenInfo,
+    amount: Web3Number,
+    usdValue: number
+  }[]> {
+    const usdceToken = Global.getDefaultTokens().find(token => token.symbol === "USDCe");
+    const wbtcToken = Global.getDefaultTokens().find(token => token.symbol === "WBTC");
+    const usdcToken = Global.getDefaultTokens().find(token => token.symbol === "USDC");
+    if (!usdceToken || !wbtcToken || !usdcToken) {
+      return [];
+    }
+    const walletAddress = this.metadata.additionalInfo.walletAddress;
+    const usdceWalletBalance = await new ERC20(this.config).balanceOf(
+      usdceToken.address,
+      walletAddress,
+      usdceToken.decimals
+    );
+    const usdcWalletBalance = await new ERC20(this.config).balanceOf(
+      usdcToken.address,
+      walletAddress,
+      usdcToken.decimals
+    );
+    const wbtcWalletBalance = await new ERC20(this.config).balanceOf(
+      wbtcToken.address,
+      walletAddress,
+      wbtcToken.decimals
+    );
+    const price = await this.pricer.getPrice(usdceToken.symbol);
+    const wbtcPrice = await this.pricer.getPrice(wbtcToken.symbol);
+    const usdceUsdValue = Number(usdceWalletBalance.toFixed(usdceToken.decimals)) * price.price;
+    const usdcUsdValue = Number(usdcWalletBalance.toFixed(usdcToken.decimals)) * price.price;
+    const wbtcUsdValue = Number(wbtcWalletBalance.toFixed(wbtcToken.decimals)) * wbtcPrice.price;
+    return [{
+      tokenInfo: usdceToken,
+      amount: usdceWalletBalance,
+      usdValue: usdceUsdValue
+    },
+    {
+      tokenInfo: usdcToken,
+      amount: usdcWalletBalance,
+      usdValue: usdcUsdValue
+    }, {
+      tokenInfo: wbtcToken,
+      amount: wbtcWalletBalance,
+      usdValue: wbtcUsdValue
+    }];
+  }
 }
 
 function getLooperSettings(
@@ -1369,6 +1519,7 @@ const re7UsdcPrimeDevansh: VesuExtendedStrategySettings = {
   ),
   borrowable_assets: [Global.getDefaultTokens().find(token => token.symbol === "WBTC")!],
   minimumWBTCDifferenceForAvnuSwap: MINIMUM_WBTC_DIFFERENCE_FOR_AVNU_SWAP,
+  walletAddress: WALLET_ADDRESS,
 }
 
 export const VesuExtendedTestStrategies = (extendedBackendUrl: string, extendedApiKey: string, vaultIdExtended: number, minimumExtendedMovementAmount: number, minimumVesuMovementAmount: number, minimumExtendedRetriesDelayForOrderStatus: number, minimumExtendedPriceDifferenceForSwapOpen: number, maximumExtendedPriceDifferenceForSwapClosing: number): IStrategyMetadata<VesuExtendedStrategySettings>[] => {