@strkfarm/sdk 1.2.0 → 2.0.0-dev-strategy2.1

package/src/strategies/btc-vesu-extended-strategy/services/operationService.ts

@@ -0,0 +1,32 @@
+import { Web3Number } from "@/dataTypes";
+import { ExtendedAdapter } from "@/strategies/universal-adapters/extended-adapter";
+import { VesuMultiplyAdapter } from "../../universal-adapters/vesu-multiply-adapter";
+import { Call } from "starknet";
+export abstract class Operations {
+  abstract shouldMoveAssets(
+    extendedAmount: Web3Number,
+    vesuAmount: Web3Number
+  ): Promise<Call[]>;
+  abstract shouldInvest(): Promise<{
+    shouldInvest: boolean;
+    collateralPrice: number;
+    wbtcAmountForStage1: Web3Number;
+  } | null>;
+  abstract moveAssets(
+    params: { from: string; to: string; amount: Web3Number },
+    extendedAdapter: ExtendedAdapter,
+    vesuAdapter: VesuMultiplyAdapter
+  ): Promise<{
+    calls: Call[];
+    status: boolean;
+  }>;
+  abstract handleWithdraw(amount: Web3Number): Promise<{
+    calls: Call[];
+    status: boolean;
+  }>;
+  abstract handleStage2Positions(): Promise<{
+    decisiveFactor: Web3Number;
+    vesuAmountInUSDC: Web3Number;
+    extendedAmountInUSDC: Web3Number;
+  }>;
+}

package/src/strategies/btc-vesu-extended-strategy/utils/constants.ts

@@ -0,0 +1,3 @@
+export const DECISIVE_FACTOR = 0.75;
+export const BUFFER_FOR_EXTENDED_DEPOSIT_AMOUNT = 0.05;
+export const AMOUNT_BUFFER_TO_KEEP_IN_INVESTING_CYCLE = 0.95;

package/src/strategies/btc-vesu-extended-strategy/utils/helper.ts

@@ -0,0 +1,396 @@
+import { Web3Number } from "@/dataTypes";
+import {
+  MAX_LTV_BTC_USDC,
+  USDC_TOKEN_DECIMALS,
+  WBTC_TOKEN_DECIMALS
+} from "@/strategies/vesu-extended-strategy/utils/constants";
+import { TARGET_HF } from "@/strategies/vesu-extended-strategy/utils/constants";
+import { logger } from "@/utils";
+import {
+  calculateExtendedLevergae,
+  calculateVesuLeverage,
+} from "../../vesu-extended-strategy/utils/helper";
+import { Position } from "@/modules";
+
+export const calculateDeltaDebtAmount = (
+  maxLtv: number = MAX_LTV_BTC_USDC,
+  extendedExposureWBTC: Web3Number, // Ee
+  assetsUnderVaultAllocator: Web3Number, // this is the aum
+  targetHf: number = TARGET_HF,
+  adddedCollateral: Web3Number, // wbtc terms
+  existingVesuCollateral: Web3Number, // C existing
+  existingVesuDebt: Web3Number, // Yc, should be in debt units
+  collateralPrice: number,
+  debtPrice: number
+) => {
+  try {
+
+    const maxLtvWeb3 = new Web3Number(maxLtv, 2);
+    const targetHfWeb3 = new Web3Number(targetHf, 2);
+    // calculation of Ce, this is the existing value in the position
+    const collateralExposureVesuInMultiplier =
+      calculateVesuExposureExtraToDepositedCollateral(
+        assetsUnderVaultAllocator,
+        adddedCollateral,
+        existingVesuCollateral
+      );
+    if (collateralExposureVesuInMultiplier === null) {
+      logger.error(
+        `error calculating collateral exposure vesu: ${collateralExposureVesuInMultiplier}`
+      );
+      return null;
+    }
+    // console.log("collateralExposureVesuInMultiplier", collateralExposureVesuInMultiplier)
+    //LHS - Maintain precision throughout calculations, only round at the end
+    const term1 = adddedCollateral.multipliedBy(maxLtv).dividedBy(targetHf);
+    const term2 = extendedExposureWBTC
+      .minus(collateralExposureVesuInMultiplier)
+      .multipliedBy(maxLtv)
+      .dividedBy(targetHf)
+      .dividedBy(4)
+      .toFixed(WBTC_TOKEN_DECIMALS);
+   
+    const term3 = existingVesuCollateral
+    const term4 = existingVesuDebt
+      .multipliedBy(debtPrice)
+      .dividedBy(collateralPrice)
+      .multipliedBy(-1)
+      .toFixed(WBTC_TOKEN_DECIMALS)
+    
+    console.log("term2", term2.toString(), term1.toString(), term3.toString(), term4.toString(), existingVesuDebt.toString());
+    // Perform addition with full precision, only round final result
+    const lhs = new Web3Number(term1.plus(term2).plus(term3).plus(term4).toFixed(WBTC_TOKEN_DECIMALS), WBTC_TOKEN_DECIMALS);
+ 
+    console.log("lhs", lhs);
+    // RHS
+    const termrhs = maxLtvWeb3
+      .dividedBy(targetHfWeb3)
+      .multipliedBy(0.75)
+      .multipliedBy(-1)
+      .plus(1)
+      .toFixed(4);
+
+    console.log("termrhs", termrhs.toString());
+    // THis will be in collateral units, since we have to match the exposure in collateral
+    // Maintain full precision during division, only round at the end
+    const calculateDeltaDebtAmount = lhs.dividedBy(termrhs);
+    // Round to WBTC decimals only at the final step to preserve precision
+    return new Web3Number(calculateDeltaDebtAmount.toFixed(WBTC_TOKEN_DECIMALS), WBTC_TOKEN_DECIMALS);
+  } catch (err) {
+    logger.error(`error calculating delta position: ${err}`);
+    return null;
+  }
+};
+
+export const calculateDecisiveFactorF = (
+  extendedExposureWBTC: Web3Number, // Ee
+  assetsUnderVaultAllocator: Web3Number,
+  adddedCollateral: Web3Number,
+  existingVesuCollateral: Web3Number, // C existing
+  unusedBalanceUSDC: Web3Number,
+  existingVesuDebt: Web3Number,
+  collateralPrice: number,
+  debtPrice: number,
+  maxLtv: number = MAX_LTV_BTC_USDC,
+  targetHf: number = TARGET_HF,
+) => {
+  try {
+    const maxLtvWeb3 = new Web3Number(maxLtv, 4);
+    const extendedLeverage= calculateExtendedLevergae();
+    // calculation of Ce
+    let collateralExposureVesu =
+      calculateVesuExposureExtraToDepositedCollateral(
+        assetsUnderVaultAllocator,
+        adddedCollateral,
+        existingVesuCollateral
+      )
+    if (collateralExposureVesu === null) {
+      logger.error(
+        `error calculating collateral exposure vesu: ${collateralExposureVesu}`
+      );
+      return null;
+    }
+    collateralExposureVesu = new Web3Number(collateralExposureVesu.toFixed(USDC_TOKEN_DECIMALS), USDC_TOKEN_DECIMALS);
+    console.log("collateralExposureVesu", collateralExposureVesu)
+    const num1 = extendedExposureWBTC.minus(collateralExposureVesu).multipliedBy(collateralPrice)
+    const num2 = unusedBalanceUSDC.multipliedBy(extendedLeverage)
+    console.log("num1", num1)
+    console.log("num2", num2)
+    const lhsterm1 = num1.plus(num2).dividedBy(1+extendedLeverage)
+
+    console.log("lhsterm1", lhsterm1)
+    const num3 = existingVesuDebt.multipliedBy(debtPrice).multipliedBy(targetHf)
+    const num4 = existingVesuCollateral.multipliedBy(collateralPrice).multipliedBy(maxLtv).multipliedBy(-1)
+    const den1 = new Web3Number((maxLtv - targetHf).toFixed(4), 4);
+    
+    console.log("num3", num3)
+    console.log("num4", num4)
+    console.log("den1", den1)
+
+    const lhsterm2 = num3.plus(num4).dividedBy(den1).dividedBy(1+extendedLeverage);
+    console.log("lhsterm2", lhsterm2)
+    const finalLhs = lhsterm1.minus(lhsterm2)
+    console.log("finalLhs", finalLhs)
+    const num5 = maxLtvWeb3.dividedBy(den1).dividedBy(1+extendedLeverage).minus(1).multipliedBy(-1).multipliedBy(unusedBalanceUSDC)
+
+    const precisionFactor = finalLhs.dividedBy(num5).toFixed(3);
+    // Maintain precision during subtraction, avoid premature rounding
+    return new Web3Number(precisionFactor, 3);
+  } catch (err) {
+    logger.error(`error calculating decisive factor f: ${err}`);
+    return null;
+  }
+};
+
+export const calculateDebtAmountForStage2 = (
+  debtAmountVesu : Web3Number,
+  collateralPrice: number,
+  debtPrice: number,
+  maxLtv: number = MAX_LTV_BTC_USDC,
+  targetHf: number = TARGET_HF,
+  collateralAmountVesu: Web3Number,
+  addedeCollateral: Web3Number,
+) => {
+  try{
+    console.log("debtAmountVesu", debtAmountVesu)
+    console.log("collateralAmountVesu", collateralAmountVesu)
+    console.log("addedeCollateral", addedeCollateral)
+    const num1 = debtAmountVesu.multipliedBy(debtPrice).multipliedBy(targetHf);
+    console.log("num1", num1)
+    const num2 = collateralAmountVesu.plus(addedeCollateral).multipliedBy(collateralPrice).multipliedBy(maxLtv).multipliedBy(-1);
+    console.log("num2", num2)
+    const den1 = maxLtv - targetHf;
+    const finalNum = num1.plus(num2);
+    console.log("finalNum", finalNum)
+    const debtAmountStage2Vesu = finalNum.dividedBy(den1).toFixed(USDC_TOKEN_DECIMALS);
+    console.log("debtAmountStage2Vesu", debtAmountStage2Vesu)
+    return new Web3Number(debtAmountStage2Vesu, USDC_TOKEN_DECIMALS);
+  }catch(err){
+    logger.error(`error calculating debt amount for stage 2: ${err}`);
+    return null;
+  }
+}
+
+
+/**
+ * Fetches the amount of exposure we have on vesu, apart from the deposited collateral
+ * @param assetsUnderVault
+ * @param userDepositedAdditionalCollateral
+ * @param vesuCollateralExposure
+ * @returns
+ */
+export const calculateVesuExposureExtraToDepositedCollateral = (
+  assetsUnderVault: Web3Number,
+  userDepositedAdditionalCollateral: Web3Number,
+  vesuCollateralExposure: Web3Number
+) => {
+  try {
+    console.log("assetsUnderVault", assetsUnderVault)
+    console.log("userDepositedAdditionalCollateral", userDepositedAdditionalCollateral)
+    console.log("vesuCollateralExposure", vesuCollateralExposure)
+    const vesuExposureExtraToDepositedCollateral = vesuCollateralExposure
+      .minus(assetsUnderVault)
+      .plus(userDepositedAdditionalCollateral).toFixed(WBTC_TOKEN_DECIMALS);
+    return new Web3Number(vesuExposureExtraToDepositedCollateral, WBTC_TOKEN_DECIMALS);
+  } catch (err) {
+    logger.error(
+      `error calculating vesu exposure extra to deposited collateral: ${err}`
+    );
+    return null;
+  }
+};
+
+
+/**
+ * Calculates the debt amount to be taken/repaid to maintain the ltv on vesu
+ * @param existingVesuDebt - existing vesu debt in usdc terms
+ * @param existingVesuCollateral - existing vesu collateral in wbtc terms
+ * @param addedCollateral - added collateral in wbtc terms
+ * @param collateralPrice - collateral price in usdc terms
+ * @param debtPrice - debt price in usdc terms
+ * @param maxLtv - max ltv
+ * @param targetHf - target hf
+ * @returns delta debt amount in usdc terms
+ */
+export const calculateDebtAmountForMainatiningLtvOnVesu = (
+  existingVesuDebt: Web3Number,
+  existingVesuCollateral: Web3Number,
+  addedCollateral: Web3Number,
+  collateralPrice: number,
+  debtPrice: number,
+  maxLtv: number = MAX_LTV_BTC_USDC,
+  targetHf: number = TARGET_HF,
+):Web3Number | null=>{
+  try{
+    logger.info(`existingVesuDebt: ${existingVesuDebt} existingVesuCollateral: ${existingVesuCollateral} addedCollateral: ${addedCollateral} collateralPrice: ${collateralPrice} debtPrice: ${debtPrice} maxLtv: ${maxLtv} targetHf: ${targetHf}`);
+    const num1 = existingVesuCollateral.plus(addedCollateral).multipliedBy(collateralPrice).multipliedBy(maxLtv);
+    const num2 = existingVesuDebt.multipliedBy(debtPrice).multipliedBy(targetHf);
+    logger.info(`num1: ${num1}`);
+    logger.info(`num2: ${num2}`);
+    const deltaDebtAmount = num1.minus(num2).dividedBy(targetHf);
+    logger.info(`delta debt amount for mainatining ltv on vesu: ${deltaDebtAmount}`);
+    return new Web3Number(deltaDebtAmount.toFixed(USDC_TOKEN_DECIMALS), USDC_TOKEN_DECIMALS);
+  }catch(err){
+    logger.error(`error calculating debt amount for mainatining ltv on vesu: ${err}`);
+    return null;
+  }
+}
+
+
+/**
+ * Calculates the vesu deposit amount for multiplier
+ * @param existingVesuDebt - existing vesu debt in usdc terms
+ * @param existingVesuCollateral - existing vesu collateral in wbtc terms
+ * @param addedCollateral - added collateral in wbtc terms
+ * @param collateralPrice - collateral price in usdc terms
+ * @param debtPrice - debt price in usdc terms
+ * @param maxLtv - max ltv
+ * @param targetHf - target hf
+ * @returns vesu deposit amount in Wbtc terms
+ */
+export const calculateVesuDepositAmountForMultiplier = (
+  decisiveFactorF: Web3Number,
+  deltaDebtAmount: Web3Number,
+  collateralPrice: number
+) => {
+  try {
+    const vesuLeverage = calculateVesuLeverage();
+    const vesuDepositAmount = decisiveFactorF
+      .multipliedBy(collateralPrice)
+      .multipliedBy(deltaDebtAmount)
+      .dividedBy(vesuLeverage)
+      .toFixed(2);
+    // base amount in usdc needed for swap to btc and open multiplier position
+    return new Web3Number(vesuDepositAmount, 2);
+  } catch (err) {
+    logger.error(`error calculating vesu deposit amount: ${err}`);
+    return null;
+  }
+};
+
+/**
+ * Calculates the extended deposit amount in usdc terms
+ * @param decisiveFactorF is the decisive factor f
+ * @param deltaDebtAmount is the delta debt amount
+ * @param collateralPrice is the collateral price in usdc terms
+ * @returns the extended deposit amount in usdc terms
+ */
+export const calculateExtendedDepositAmount = (
+  decisiveFactorF: Web3Number,
+  deltaDebtAmount: Web3Number,
+  collateralPrice: number
+) => {
+  try {
+    const multiplier = decisiveFactorF.minus(1).multipliedBy(-1);
+    // Extended position size in WBTC without Leverage, position will not be opened for whole amount, this is rather just to move assets
+    const extendedDepositAmount = deltaDebtAmount
+      .multipliedBy(multiplier).multipliedBy(collateralPrice).toFixed(2);
+    logger.info(`:calculateExtendedDepositAmount extendedPositionSize: ${extendedDepositAmount}`);
+    return new Web3Number(extendedDepositAmount,2);
+  } catch (err) {
+    logger.error(`error calculating extende deposit amount: ${err}`);
+    return null;
+  }
+};
+
+
+/**
+ * Calculates the borrow amount for stage 1 in usdc terms
+ * @param targetHealthFactor is the target health factor
+ * @param maxLtv is the max ltv
+ * @param existingVesuCollateral is the existing vesu collateral in wbtc terms
+ * @param addedCollateral is the added collateral in wbtc terms
+ * @param collateralPrice is the collateral price in usdc terms
+ * @param debtPrice 
+ * @returns the borrow amount for stage 1 in usdc terms
+ */
+export const calculateBorrowAmountForStage1 =(
+  targetHealthFactor: number,
+  maxLtv: number = MAX_LTV_BTC_USDC,
+  existingVesuCollateral: Web3Number, // this is equal to the assets under management in wbtc terms
+  addedCollateral: Web3Number,
+  collateralPrice: number,
+  debtPrice: number
+)=>{
+  try{
+    console.log("collateralPrice", collateralPrice)
+    console.log("debtPrice", debtPrice)
+    console.log("existingVesuCollateral", existingVesuCollateral.toString())
+    console.log("addedCollateral", addedCollateral.toString())
+    console.log("maxLtv", maxLtv)
+    console.log("targetHealthFactor", targetHealthFactor)
+    // Maintain full precision throughout calculations
+    const numerator1 = existingVesuCollateral.plus(addedCollateral).multipliedBy(collateralPrice).multipliedBy(maxLtv).dividedBy(targetHealthFactor);
+    logger.info(`numerator1 :: ${numerator1}`);
+    const existingVesuDebt = existingVesuCollateral.multipliedBy(collateralPrice).multipliedBy(maxLtv).dividedBy(targetHealthFactor).dividedBy(debtPrice);
+    const numerator3 = existingVesuDebt.multipliedBy(debtPrice).multipliedBy(-1);
+    logger.info(`numerator3 :: ${numerator3}`);
+    const deltaYStage1 = numerator1.plus(numerator3);
+    logger.info(`deltaYStage1 :: ${deltaYStage1}`);
+    return new Web3Number(deltaYStage1.toFixed(USDC_TOKEN_DECIMALS), USDC_TOKEN_DECIMALS);
+  }catch(err){
+    logger.error(`error calculating borrow amount for stage 1: ${err}`);
+    return null;
+  }
+}
+
+
+/**
+ * Calculates the amount distribution for withdrawal in wbtc strategy
+ * @param amountInWbtc is the amount in wbtc terms
+ * @param collateralPrice is the collateral price in usdc terms
+ * @param vesuCollateralExposure is the vesu collateral exposure in wbtc terms
+ * @param extendedPosition is the extended position exposure in wbtc terms
+ * @returns the amount distribution for withdrawal in wbtc strategy
+ */
+export const calculateAmountDistributionForWithdrawalInWbtcStrategy = (
+  amountInWbtc: Web3Number,
+  vesuCollateralExposure: Web3Number,
+  extendedPosition: Position[] | null
+) => {
+  try {
+    const extended_leverage = calculateExtendedLevergae();
+    const vesu_leverage = calculateVesuLeverage();
+    if (extendedPosition === null) {
+      logger.error("error getting extended positions");
+      return null;
+    }
+    const extendedExposureWBTC =
+    extendedPosition.length > 0
+    ? new Web3Number(extendedPosition[0].size, WBTC_TOKEN_DECIMALS)
+    : new Web3Number(0,WBTC_TOKEN_DECIMALS);
+    if (vesuCollateralExposure.lessThanOrEqualTo(0)) {
+      return {
+        vesuAmount: new Web3Number(0, USDC_TOKEN_DECIMALS),
+        extendedAmount: amountInWbtc,
+        extended_leverage,
+        vesu_leverage,
+      };
+    }
+    if (extendedExposureWBTC.lessThanOrEqualTo(0)) {
+      return {
+        vesuAmount: amountInWbtc,
+        extendedAmount: new Web3Number(0, WBTC_TOKEN_DECIMALS),
+        extended_leverage,
+        vesu_leverage,
+      };
+    }
+    const numerator1 = amountInWbtc.multipliedBy(vesu_leverage);
+    const numerator2 = extendedExposureWBTC.multipliedBy(extended_leverage);
+    const numerator3 = vesuCollateralExposure.multipliedBy(vesu_leverage).multipliedBy(-1);
+    const finalNumerator = numerator1.plus(numerator2).plus(numerator3);
+    const denominator = vesu_leverage + extended_leverage;
+    const extendedAmountInWBTC = finalNumerator.dividedBy(denominator);
+    const vesuAmountInWBTC = amountInWbtc.minus(extendedAmountInWBTC);
+    return {
+      vesuAmount: vesuAmountInWBTC,
+      extendedAmount: extendedAmountInWBTC,
+      extended_leverage,
+      vesu_leverage,
+    }
+  }catch(err){
+    logger.error(`error calculating amount distribution for withdrawal in wbtc strategy: ${err}`);
+    return null;
+  }
+}
+

package/src/strategies/btc-vesu-extended-strategy/utils/types.ts

@@ -0,0 +1,5 @@
+import { Web3Number } from "@/dataTypes"
+export interface DepositParamsForLendingBorrowing {
+  supplyAmount: Web3Number;
+  debtAmount: Web3Number;
+}