@strkfarm/sdk 1.1.70 → 2.0.0-dev.2

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

@@ -0,0 +1,34 @@
+import { Web3Number } from "@/dataTypes";
+import { TokenInfo } from "@/interfaces";
+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;
+    vesuAmount: Web3Number;
+    extendedAmount: Web3Number;
+    extendedLeverage: number;
+    vesuLeverage: number;
+  }>;
+  abstract moveAssets(
+    params: { from: string; to: string; amount: Web3Number },
+    extendedAdapter: ExtendedAdapter,
+    vesuAdapter: VesuMultiplyAdapter
+  ): Promise<{
+    calls: Call[];
+    status: boolean;
+  }>;
+  abstract handleDeposit(): Promise<{
+    extendedAmountInBTC: Web3Number;
+    calls: Call[];
+  }>;
+  abstract handleWithdraw(amount: Web3Number): Promise<{
+    calls: Call[];
+    status: boolean;
+  }> ;
+}

package/src/strategies/vesu-extended-strategy/utils/config.runtime.ts

@@ -0,0 +1,77 @@
+import {
+  AVNU_API,
+  USDC_TOKEN_ADDRESS,
+  USDC_TOKEN_DECIMALS,
+  WBTC_TOKEN_ADDRESS,
+  WBTC_TOKEN_DECIMALS,
+  WALLET_ADDRESS,
+  EXTEND_CONTRACT_ADDRESS,
+  MULTIPLY_CONTRACT_ADDRESS,
+  EXTENDED_BASE_URL,
+  EXTEND_MARKET_NAME,
+  EXTENDED_QTY_PRECISION,
+  EXTENDED_FEES,
+  MAINTENANCE_MARGIN,
+  VESU_POOL_ID,
+  MAX_LTV_BTC_USDC,
+  MAX_LIQUIDATION_RATIO,
+  TARGET_HF,
+  EKUBO_ENDPOINT,
+  PRICE_MAX_SLIPPAGE_EKUBO,
+  MINIMUM_DEBT_AMOUNT_VESU_FOR_REBALANCING,
+  MINIMUM_EXTENDED_POSITION_SIZE
+} from "./constants"
+import VesuPoolV2Abi from '@/data/vesu-pool-v2.abi.json';
+import ExtendedDepositAbi from '@/data/extended-deposit.abi.json';
+import VesuMultiplyAbi from '@/data/vesu-multiple.abi.json';
+
+// Grouped, readable configuration (no behavior change). Consumers can migrate gradually.
+
+export const AddressesConfig = {
+  tokens: {
+    USDC: { address: USDC_TOKEN_ADDRESS, decimals: USDC_TOKEN_DECIMALS },
+    WBTC: { address: WBTC_TOKEN_ADDRESS, decimals: WBTC_TOKEN_DECIMALS },
+  },
+  contracts: {
+    EXTENDED: EXTEND_CONTRACT_ADDRESS,
+    MULTIPLY: MULTIPLY_CONTRACT_ADDRESS,
+  },
+  wallet: {
+    address: WALLET_ADDRESS,
+  },
+} as const;
+
+export const ExtendedConfig = {
+  baseUrl: EXTENDED_BASE_URL,
+  marketName: EXTEND_MARKET_NAME,
+  maintenanceMargin: MAINTENANCE_MARGIN,
+  precision: EXTENDED_QTY_PRECISION,
+  fees: EXTENDED_FEES,
+  minPositionSize: MINIMUM_EXTENDED_POSITION_SIZE,
+} as const;
+
+export const VesuConfig = {
+  poolId: VESU_POOL_ID,
+  maxLtv: MAX_LTV_BTC_USDC,
+  maxLiquidationRatio: MAX_LIQUIDATION_RATIO,
+  targetHealthFactor: TARGET_HF,
+  ekubo: {
+    endpoint: EKUBO_ENDPOINT,
+    priceMaxSlippage: PRICE_MAX_SLIPPAGE_EKUBO,
+  },
+  avnu: {
+    api: AVNU_API,
+  },
+  minDebtForVesuRebalacing:MINIMUM_DEBT_AMOUNT_VESU_FOR_REBALANCING
+} as const;
+
+export const AbisConfig = {
+  vesu: {
+    multiply: VesuMultiplyAbi,
+    pool: VesuPoolV2Abi,
+  },
+  extended: {
+    contract: ExtendedDepositAbi,
+  },
+} as const;
+

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

@@ -0,0 +1,49 @@
+export const AVNU_API = "https://starknet.api.avnu.fi/swap/v2/quotes";
+export const SLIPPAGE = 0.01;
+export const USDC_TOKEN_DECIMALS = 6;
+export const USDC_TOKEN_ADDRESS =
+  "0x053C91253BC9682c04929cA02ED00b3E423f6710D2ee7e0D5EBB06F3eCF368A8";
+export const BUFFER_USDC_IN_WITHDRAWAL=5;
+export const WBTC_TOKEN_ADDRESS = "0x3fe2b97c1fd336e750087d68b9b867997fd64a2661ff3ca5a7c771641e8e7ac";
+export const WBTC_TOKEN_DECIMALS = 8;
+export const MAINTENANCE_MARGIN = 0.01;
+export const MAX_PRICE_DROP_PERCENTAGE = Number(process.env.MAX_PRICE_DROP_PERCENTAGE ?? 0.25);
+export const MAX_LTV_BTC_USDC =  0.8428;
+export const MAX_LIQUIDATION_RATIO =  0.86;
+export const VAULT_ID_EXTENDED= process.env.VAULT_ID_EXTENDED ?? 220774;
+export const WALLET_ADDRESS =
+  process.env.WALLET_ADDRESS ?? "0x07b84bb6E87588BdAde0bfe6173A615b3C220F9C3803456aE183C50EA1d15Ba1";
+export const TESTNET_WALLET_ADDRESS =
+  process.env.TESTNET_WALLET_ADDRESS ?? "0x07b84bb6E87588BdAde0bfe6173A615b3C220F9C3803456aE183C50EA1d15Ba1";
+export const TEST_WALLET_2 =
+  process.env.TEST_WALLET_2 ?? "0x004C1bdC61DAc7947F3C93d0163d660012E2aB0521567f7155fcf502848791A7";
+export const STRK_API_TEST_RPC = process.env.STRK_API_TEST_RPC ?? "https://sepolia.starknet.a5a.ch";
+export const STRK_API_RPC = process.env.STRK_API_RPC ?? "https://mainnet.starknet.a5a.ch";
+export const MAX_RETRIES = Number(process.env.MAX_RETRIES ?? 3);
+export const MAX_DELAY = Number(process.env.MAX_DELAY ?? 100);
+export const EXTEND_MARKET_NAME = "BTC-USD";
+export const LIMIT_BALANCE = Number(process.env.LIMIT_BALANCE ?? 10);
+export const REBALANCER_INTERVAL = Number(process.env.REBALANCER_INTERVAL ?? 180000); //3 mins
+export const WITHDRAWAL_INTERVAL = Number(process.env.WITHDRAWAL_INTERVAL ?? 18000000); //5 hours
+export const INVESTING_INTERVAL = Number(process.env.INVESTING_INTERVAL ?? 180000); //3 mins
+export const MAXIMUM_DELTA = Number(process.env.MAXIMUM_DELTA ?? 5);
+export const EXTENDED_BASE_URL = process.env.EXTENDED_BASE_URL ?? "https://api.starknet.extended.exchange";
+export const VESU_POOL_ID = "0x02eef0c13b10b487ea5916b54c0a7f98ec43fb3048f60fdeedaf5b08f6f88aaf";
+export const EKUBO_ENDPOINT = "https://quoter-mainnet-api.ekubo.org/{{AMOUNT}}/{{TOKEN_FROM_ADDRESS}}/{{TOKEN_TO_ADDRESS}}"; // e.g. ETH/USDC'
+export const TARGET_HF = Number(process.env.TARGET_HF ?? 1.4);
+export const MULTIPLY_CONTRACT_ADDRESS = "0x07964760e90baa28841ec94714151e03fbc13321797e68a874e88f27c9d58513";
+export const EXTEND_CONTRACT_ADDRESS = "0x062da0780fae50d68cecaa5a051606dc21217ba290969b302db4dd99d2e9b470";
+export const EXTENDED_QTY_PRECISION =  5;
+export const EXTENDED_FEES= Number(process.env.EXTENDED_FEES ?? 0.006);
+export const REBALANCE_PRICE_DROP_PERCENTAGE = Number(process.env.REBALANCE_PRICE_DROP_PERCENTAGE ?? 3);
+export const PRICE_MAX_SLIPPAGE_EKUBO = Number(process.env.PRICE_MAX_SLIPPAGE_EKUBO ?? 0.005);
+export const MINIMUM_DEBT_AMOUNT_VESU_FOR_REBALANCING = Number(process.env.MINIMUM_DEBT_AMOUNT_VESU_FOR_REBALANCING ?? 1);
+export const MINIMUM_EXTENDED_POSITION_SIZE =  0.0001;
+export const MINIMUM_WBTC_DIFFERENCE_FOR_AVNU_SWAP = 0.00001;
+export const MAX_PRICE_DIFFERENCE_BETWEEN_AVNU_AND_EXTENDED = 700;
+export const MIN_PRICE_DIFFERENCE_BETWEEN_AVNU_AND_EXTENDED = -100;
+
+//STATUS CODES
+export const SUCCESS_STATUS_CODE = 200;
+export const ERROR_STATUS_CODE = 500;
+export const BAD_REQUEST_STATUS_CODE = 400;

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

@@ -0,0 +1,376 @@
+import {
+  MAINTENANCE_MARGIN,
+  MAX_LTV_BTC_USDC,
+  MAX_PRICE_DROP_PERCENTAGE,
+  TARGET_HF,
+  WBTC_TOKEN_ADDRESS,
+  USDC_TOKEN_ADDRESS,
+  WBTC_TOKEN_DECIMALS,
+  USDC_TOKEN_DECIMALS,
+  MAX_LIQUIDATION_RATIO,
+} from "./constants";
+import { Web3Number } from "@/dataTypes";
+import { Position } from "@/modules/ExtendedWrapperSDk";
+// import { getAllOpenPositionsExtended } from "../services/extendedService";
+import ExtendedWrapper from "@/modules/ExtendedWrapperSDk";
+import { logger } from "@/utils";
+// import {
+//   calculatePositionOnVesu,
+//   getAssetPrice,
+// } from "../services/vesuService";
+/**
+ * Function to return formatted amount to BigInt
+ * Converts a decimal amount to the proper format for blockchain transactions
+ * @param {number} amount - The decimal amount to convert
+ * @param {number} fromTokenDecimals - The decimal precision of the token
+ * @returns {string} The formatted amount as a hexadecimal string
+ */
+export const returnFormattedAmount = (
+  amount: number,
+  toTokenDecimals: number
+) => {
+  const formattedAmount =
+    "0x" + BigInt(Math.floor(amount * 10 ** toTokenDecimals)).toString(16);
+  return formattedAmount;
+};
+
+/**
+ * calculates the amount to distribute to Extend and Vesu
+ * Determines how much to allocate to each platform based on leverage calculations
+ * @param {number} amount - The total amount to distribute
+ * @returns {object} Object containing avnu_amount, extended_amount, and extended_leverage
+ */
+export const calculateAmountDistribution = async (
+  amount: number,
+  client: ExtendedWrapper,
+  marketName: string,
+  collateralPrice: number,
+  debtPrice: number,
+  collateralUnits: Web3Number,
+  extendedPosition: Position[] | null
+): Promise<{
+  vesu_amount: Web3Number;
+  extended_amount: Web3Number;
+  extended_leverage: number;
+  vesu_leverage: number;
+}> => {
+  try {
+    const extended_leverage = calculateExtendedLevergae();
+    const vesu_leverage = calculateVesuLeverage();
+    if (extendedPosition === null) {
+      logger.error("error getting extended positions");
+      return {
+        vesu_amount: new Web3Number(0, 0),
+        extended_amount: new Web3Number(0, 0),
+        extended_leverage: 0,
+        vesu_leverage: 0,
+      };
+    }
+    const extendedBTCExposure =
+      extendedPosition.length > 0
+        ? new Web3Number(extendedPosition[0].size, WBTC_TOKEN_DECIMALS)
+        : new Web3Number(0, WBTC_TOKEN_DECIMALS);
+    const extendedExposureUSD =
+      extendedBTCExposure.multipliedBy(collateralPrice);
+    const vesuBTCExposureUSD = collateralUnits.multipliedBy(collateralPrice);
+    const numerator1 = vesu_leverage * amount + vesuBTCExposureUSD.toNumber();
+    const numerator2 = extendedExposureUSD.toNumber();
+    const denominator = vesu_leverage + extended_leverage;
+    const ExtendedAmount = new Web3Number(
+      ((numerator1 - numerator2) / denominator).toFixed(2),
+      USDC_TOKEN_DECIMALS
+    );
+
+    const VesuAmount = new Web3Number(
+      amount.toFixed(2),
+      USDC_TOKEN_DECIMALS
+    ).minus(ExtendedAmount);
+
+    return {
+      vesu_amount: VesuAmount,
+      extended_amount: ExtendedAmount,
+      extended_leverage,
+      vesu_leverage,
+    };
+  } catch (err) {
+    return {
+      vesu_amount: new Web3Number(0, 0),
+      extended_amount: new Web3Number(0, 0),
+      extended_leverage: 0,
+      vesu_leverage: 0,
+    };
+  }
+};
+
+/**
+ * calculate the amount distribution for withdrawal
+ * @param amount - The amount to withdraw
+ * @param client - The client
+ * @param marketName - The market name
+ * @returns {object} Object containing avnu_amount and extended_amount
+ */
+export const calculateAmountDistributionForWithdrawal = async (
+  amountInUsdc: Web3Number,
+  collateralPrice: number,
+  collateralUnits: Web3Number,
+  extendedPosition: Position[] | null
+): Promise<{
+  vesu_amount: Web3Number;
+  extended_amount: Web3Number;
+  extended_leverage: number;
+  vesu_leverage: number;
+} | null> => {
+  try {
+    const extended_leverage = calculateExtendedLevergae();
+    const vesu_leverage = calculateVesuLeverage();
+    if (extendedPosition === null) {
+      logger.error("error getting extended positions");
+      return null;
+    }
+    const extendedExposureUSD =
+    extendedPosition.length > 0
+    ? new Web3Number(extendedPosition[0].value, USDC_TOKEN_DECIMALS)
+    : new Web3Number(0, USDC_TOKEN_DECIMALS);
+    console.log("THe collateral is", collateralPrice, collateralUnits);
+    // console.log("the extended exposure usd is", extendedExposureUSD.toNumber());
+    //console.log("the collateral units are", collateralUnits.toNumber());\
+    const vesuExposureUSD = collateralUnits.multipliedBy(collateralPrice);
+    if (vesuExposureUSD.lessThan(0)) {
+      return {
+        vesu_amount: new Web3Number(0, USDC_TOKEN_DECIMALS),
+        extended_amount: amountInUsdc,
+        extended_leverage,
+        vesu_leverage,
+      };
+    }
+    if (extendedExposureUSD.lessThan(0)) {
+      return {
+        vesu_amount: amountInUsdc,
+        extended_amount: new Web3Number(0, USDC_TOKEN_DECIMALS),
+        extended_leverage,
+        vesu_leverage,
+      };
+    }
+    console.log("the vesu exposure usd is", vesuExposureUSD.toNumber());
+    console.log("the extended exposure usd is", extendedExposureUSD.toNumber());
+    console.log("the amount in usdc is", amountInUsdc.toNumber());
+    console.log("the extended leverage is", extended_leverage);
+    console.log("the vesu leverage is", vesu_leverage);
+    const numerator1 = amountInUsdc.multipliedBy(extended_leverage);
+    const numerator2 = vesuExposureUSD;
+    const numerator3 = extendedExposureUSD
+      .multipliedBy(-1);
+    const finalNumerator = numerator1.plus(numerator2).plus(numerator3);
+    const denominator = extended_leverage + vesu_leverage;
+    const vesuAmountInUSDC = finalNumerator.dividedBy(denominator);
+    console.log("the vesu amount in usdc is", vesuAmountInUSDC.toNumber());
+    const extendedAmountInUSDC = amountInUsdc.minus(vesuAmountInUSDC);
+    console.log(
+      "the extended amount in usdc is",
+      extendedAmountInUSDC.toNumber()
+    );
+    //console.log("the vesu amount in usdc is", vesuAmountInUSDC.toNumber());
+    //console.log("the extended amount in usdc is", extendedAmountInUSDC.toNumber());\
+    await new Promise((resolve) => setTimeout(resolve, 10000));
+    return {
+      vesu_amount: vesuAmountInUSDC,
+      extended_amount: extendedAmountInUSDC,
+      extended_leverage,
+      vesu_leverage,
+    };
+  } catch (err) {
+    logger.error(`error calculating amount distribution for withdrawal: ${err}`);
+    return null;
+  }
+};
+/**
+ * calculate the leverage required for Avnu
+ * calculates the optimal leverage for Avnu based on LTV ratios and price drop protection
+ * @returns {number} The calculated leverage value
+ */
+export const calculateVesuLeverage = () => {
+  const max_ltv_ratio = (1 - MAX_PRICE_DROP_PERCENTAGE) * MAX_LIQUIDATION_RATIO; //0.75
+  const our_ltv_ratio = Math.floor(max_ltv_ratio * 100) - 5; //buffer of 5% to prevent liquidation
+  const leverage = 1 / (1 - our_ltv_ratio / 100);
+  return Math.ceil(leverage * 10) / 10;
+};
+
+/**
+ * calculate leverage for extended
+ * calculates the maximum safe leverage for Extended based on maintenance margin and price drop protection
+ * @returns {number} The calculated leverage value
+ */
+export const calculateExtendedLevergae = () => {
+  const extended_leverage_max =
+    1 / (MAINTENANCE_MARGIN + MAX_PRICE_DROP_PERCENTAGE);
+  return Math.floor(extended_leverage_max);
+};
+
+/**
+ * calculates the debt amount for leverage operations
+ * Determines how much debt to add or remove based on collateral changes and target health factor
+ * @param {Web3Number} collateralAmount - Current collateral amount
+ * @param {Web3Number} debtAmount - Current debt amount
+ * @param {number} debtPrice - Current price of the debt token
+ * @param {number} maxLtv - Maximum loan-to-value ratio (default: MAX_LTV_BTC_USDC)
+ * @param {number} addedAmount - Amount being added to collateral
+ * @param {number} collateralPrice - Current price of the collateral token
+ * @param {boolean} isDeposit - Whether this is a deposit (true) or withdrawal (false)
+ * @returns {object} Object containing deltadebtAmountUnits and isIncrease flag
+ */
+// In case BTC_PRICE DROPS the added amount will be zero, and use this formula to calculated the debt that needs to be paid to maintain the ltv
+export const calculateDebtAmount = (
+  collateralAmount: Web3Number,
+  debtAmount: Web3Number,
+  debtPrice: number,
+  maxLtv: number = MAX_LTV_BTC_USDC,
+  addedAmount: Web3Number, // this is in btc
+  collateralPrice: number,
+  isDeposit: boolean
+) => {
+  try {
+    // => X = (((collateral + legDepositAmount) * collateralPrice * ltv) - (debt * debtPrice * target hf)) / (target hf - ltv)
+    const marginAmount = addedAmount.multipliedBy(isDeposit ? 1 : -1);
+    const numerator1 = collateralAmount
+      .plus(addedAmount)
+      .multipliedBy(collateralPrice)
+      .multipliedBy(maxLtv);
+    const numerator2 = debtAmount
+      .multipliedBy(debtPrice)
+      .multipliedBy(TARGET_HF);
+    const denominator = TARGET_HF - maxLtv;
+    const x_debt_usd = numerator1.minus(numerator2).dividedBy(denominator);
+    let deltadebtAmountUnits = new Web3Number(
+      x_debt_usd.dividedBy(debtPrice).toFixed(2),
+      2
+    );
+    let isIncrease = x_debt_usd.greaterThan(0);
+    return { deltadebtAmountUnits, isIncrease };
+  } catch (err) {
+    return { deltadebtAmountUnits: null, isIncrease: null };
+  }
+};
+
+/**
+ * calculate the debt amount to be repaid for withdrawal
+ * @param debtAmount in debt units
+ * @param collateralAmount in collateral units
+ * @param maxLtv in percentage
+ * @param withdrawalAmount in collateral units
+ * @param collateralPrice in usd
+ * @param debtPrice in usd
+ * @returns deltadebtAmountUnits in debt units
+ *          isIncrease: true if the debt amount is increasing, false if it is decreasing
+ */
+export const calculateDebtReductionAmountForWithdrawal = (
+  debtAmount: Web3Number,
+  collateralAmount: Web3Number,
+  maxLtv: number = MAX_LTV_BTC_USDC,
+  withdrawalAmount: Web3Number,
+  collateralPrice: number,
+  debtPrice: number,
+  usdcDecimals: number
+) => {
+  try {
+    const vesuLeverage = calculateVesuLeverage();
+    const numerator1 = collateralAmount
+      .multipliedBy(collateralPrice)
+      .multipliedBy(maxLtv)
+      .multipliedBy(-1);
+    withdrawalAmount = withdrawalAmount.multipliedBy(vesuLeverage);
+    const numerator2 = debtAmount
+      .multipliedBy(debtPrice)
+      .multipliedBy(TARGET_HF);
+    const numerator3 = withdrawalAmount
+      .multipliedBy(collateralPrice)
+      .multipliedBy(maxLtv);
+    const numeratorTotal = numerator1.plus(numerator2).plus(numerator3);
+    const denominator = debtPrice * TARGET_HF;
+    const x_debt_usdc = numeratorTotal.dividedBy(denominator);
+    let deltadebtAmountUnits = x_debt_usdc
+      .multipliedBy(-1)
+      .toFixed(usdcDecimals); // means we are paying debt
+    return { deltadebtAmountUnits };
+  } catch (err) {
+    return { deltadebtAmountUnits: null };
+  }
+};
+
+/**
+ * calculate the amount to deposit on extended when incurring losses
+ * @param client - The client
+ * @returns The amount to deposit on extended when incurring losses
+ */
+export const calculateAmountDepositOnExtendedWhenIncurringLosses = async (
+  client: ExtendedWrapper
+) => {
+  try {
+    const extendedHoldings = await client.getHoldings();
+    const extended_leverage = calculateExtendedLevergae();
+    const latestPosition = (await client.getPositions()).data.pop();
+    console.log("the latest position is", latestPosition, extendedHoldings);
+    if (!extendedHoldings || !latestPosition) {
+      logger.error(`error getting extended position: extendedHoldings=${extendedHoldings}, latestPosition=${latestPosition}`);
+      return null;
+    }
+    const positionValueInUSD = latestPosition.value;
+    const equity = extendedHoldings.data.equity;
+    const deposit =
+      Number(positionValueInUSD) / extended_leverage - Number(equity);
+    return new Web3Number(Math.floor(deposit / 0.2) * 0.2, USDC_TOKEN_DECIMALS);
+  } catch (err) {
+    return null;
+  }
+};
+
+export const calculateExposureDelta = (
+  exposure_extended: number,
+  exposure_vesu: number
+) => {
+  const exposure_delta = new Web3Number(exposure_extended - exposure_vesu, 2);
+  return exposure_delta.absoluteValue().toNumber();
+};
+
+/// In case BTC PRICE DROPS
+// 1. calculate the ltv on vesu
+// 2. Find the debt that needs to be paid to maintain the ltv
+
+/**
+ * calculate the delta percentage between the current btc price and the last btc price
+ * @param {number} btcPrice - The current btc price
+ * @param {number} lastBtcPrice - The last btc price
+ * @returns {number} The delta percentage
+ */
+export const calculateBTCPriceDelta = (
+  btcPrice: number,
+  lastBtcPrice: number
+) => {
+  return ((btcPrice - lastBtcPrice) / lastBtcPrice) * 100;
+};
+
+export const calculateVesUPositionSizeGivenExtended = (
+  extendedPositonValue: number,
+  extendedHoldingAmount: Web3Number,
+  collateralAmount: Web3Number,
+  collateralPrice: number
+) => {
+  const extendedLeverage = calculateExtendedLevergae();
+  const vesuLeverage = calculateVesuLeverage();
+  const extendedAmount = extendedHoldingAmount;
+  const extendedAmountInBTC = extendedAmount
+    .dividedBy(collateralPrice)
+  const numerator1 = extendedAmount.multipliedBy(extendedLeverage)
+    .plus(extendedPositonValue)
+  const numerator2 = collateralAmount
+    .multipliedBy(collateralPrice)
+    .multipliedBy(-1);
+  const vesuAmountInUsd = numerator1.plus(numerator2).dividedBy(vesuLeverage);
+  const vesuAmountInBTC = vesuAmountInUsd
+    .dividedBy(collateralPrice)
+    .toFixed(WBTC_TOKEN_DECIMALS);
+  return {
+    vesuAmountInUsd: vesuAmountInUsd.toFixed(2),
+    vesuAmountInBTC: new Web3Number(vesuAmountInBTC, WBTC_TOKEN_DECIMALS),
+    extendedAmountInBTC: extendedAmountInBTC,
+  };
+};