@strkfarm/sdk 2.0.0-dev.23 → 2.0.0-dev.25

package/dist/index.browser.global.js

@@ -28729,6 +28729,7 @@ ${r2}}` : "}", l2;
     calculateDeltaDebtAmount: () => calculateDeltaDebtAmount,
     calculateExposureDelta: () => calculateExposureDelta,
     calculateExtendedLevergae: () => calculateExtendedLevergae,
+    calculatePositionToCloseToWithdrawAmount: () => calculatePositionToCloseToWithdrawAmount,
     calculateVesUPositionSizeGivenExtended: () => calculateVesUPositionSizeGivenExtended,
     calculateVesuLeverage: () => calculateVesuLeverage,
     calculateWBTCAmountToMaintainLTV: () => calculateWBTCAmountToMaintainLTV,
@@ -92523,7 +92524,9 @@ spurious results.`);
         vesu_leverage
       };
     } catch (err2) {
-      logger2.error(`error calculating amount distribution for withdrawal: ${err2}`);
+      logger2.error(
+        `error calculating amount distribution for withdrawal: ${err2}`
+      );
       return null;
     }
   };
@@ -92576,15 +92579,22 @@ spurious results.`);
       const extended_leverage = calculateExtendedLevergae();
       const latestPosition = (await client.getPositions()).data.pop();
       if (!extendedHoldings || !latestPosition) {
-        logger2.error(`error getting extended position: extendedHoldings=${extendedHoldings}, latestPosition=${latestPosition}`);
+        logger2.error(
+          `error getting extended position: extendedHoldings=${extendedHoldings}, latestPosition=${latestPosition}`
+        );
         return null;
       }
-      const positionValueInUSD = new Web3Number(latestPosition.value, USDC_TOKEN_DECIMALS);
+      const positionValueInUSD = new Web3Number(
+        latestPosition.value,
+        USDC_TOKEN_DECIMALS
+      );
       const equity = extendedHoldings.data.equity;
       const deposit = positionValueInUSD.dividedBy(extended_leverage).minus(equity).toFixed(2);
       return new Web3Number(deposit, USDC_TOKEN_DECIMALS);
     } catch (err2) {
-      logger2.error(`error calculating amount deposit on extended when incurring losses: ${err2}`);
+      logger2.error(
+        `error calculating amount deposit on extended when incurring losses: ${err2}`
+      );
       return null;
     }
   };
@@ -92636,6 +92646,26 @@ spurious results.`);
       return null;
     }
   };
+  var calculatePositionToCloseToWithdrawAmount = async (extendedBalance, extendedPositions, amountToWithdraw) => {
+    try {
+      const extendedLeverage = calculateExtendedLevergae();
+      const extendedPosition = extendedPositions.value;
+      const marginRequired = new Web3Number(extendedBalance.initialMargin, USDC_TOKEN_DECIMALS);
+      const unrealisedPnl = new Web3Number(extendedBalance.unrealisedPnl, USDC_TOKEN_DECIMALS);
+      const availableForWithdrawal = new Web3Number(extendedBalance.availableForWithdrawal, USDC_TOKEN_DECIMALS);
+      const upnlPercent = unrealisedPnl.dividedBy(extendedPosition);
+      console.log(`upnlPercent: ${upnlPercent}`);
+      const walletBalance = new Web3Number(extendedBalance.balance, USDC_TOKEN_DECIMALS);
+      const term1 = marginRequired.minus(walletBalance).minus(availableForWithdrawal).plus(amountToWithdraw).multipliedBy(extendedLeverage);
+      const denominator = upnlPercent.multipliedBy(extendedLeverage).plus(1);
+      return new Web3Number(Math.ceil(term1.dividedBy(denominator).dividedBy(extendedLeverage).toNumber()), USDC_TOKEN_DECIMALS);
+    } catch (err2) {
+      logger2.error(
+        `error calculating position to close to withdraw amount: ${err2}`
+      );
+      return new Web3Number(0, USDC_TOKEN_DECIMALS);
+    }
+  };
 
   // src/utils/health-factor-math.ts
   var HealthFactorMath = class {
@@ -99224,6 +99254,19 @@ spurious results.`);
           logger2.info(
             `${_VesuExtendedMultiplierStrategy.name}::moveAssets extendedHoldingAmount: ${extendedHoldingAmount.toNumber()}`
           );
+          const extendedPositions = await extendedAdapter.getAllOpenPositions();
+          if (!extendedPositions) {
+            logger2.error(
+              `error getting extended positions: ${extendedPositions} while moving assets from extended to vault`
+            );
+            return this.createTransactionResult(
+              [],
+              false,
+              params,
+              "NONE",
+              params.cycleType
+            );
+          }
           if (params.amount.abs().greaterThan(extendedHoldingAmount)) {
             const leftAmountAfterWithdrawalAmountInAccount = new Web3Number(
               Math.ceil(
@@ -99231,6 +99274,14 @@ spurious results.`);
               ),
               USDC_TOKEN_DECIMALS
             );
+            const positionAmountToClose = await calculatePositionToCloseToWithdrawAmount(
+              extendedHoldings,
+              extendedPositions[0],
+              params.amount
+            );
+            logger2.info(
+              `positionAmountToClose: ${positionAmountToClose} this is without leverage`
+            );
             logger2.info(
               `${_VesuExtendedMultiplierStrategy.name}::moveAssets leftAmountAfterWithdrawalAmountInAccount: ${leftAmountAfterWithdrawalAmountInAccount.toNumber()}`
             );
@@ -99243,7 +99294,7 @@ spurious results.`);
               logger2.error(`error fetching order book btc usdc: ${status}`);
               priceOfBTC = collateralPrice.price;
             }
-            const btcAmount = leftAmountAfterWithdrawalAmountInAccount.dividedBy(priceOfBTC);
+            const btcAmount = positionAmountToClose.dividedBy(priceOfBTC);
             const openLongPosition = btcAmount.multipliedBy(3).greaterThan(MINIMUM_EXTENDED_POSITION_SIZE) ? await extendedAdapter.createOrder(
               extendedLeverage.toString(),
               btcAmount.toNumber(),

package/dist/index.browser.mjs

@@ -28479,7 +28479,9 @@ var calculateAmountDistributionForWithdrawal = async (amountInUsdc, collateralPr
       vesu_leverage
     };
   } catch (err) {
-    logger.error(`error calculating amount distribution for withdrawal: ${err}`);
+    logger.error(
+      `error calculating amount distribution for withdrawal: ${err}`
+    );
     return null;
   }
 };
@@ -28532,15 +28534,22 @@ var calculateAmountDepositOnExtendedWhenIncurringLosses = async (client) => {
     const extended_leverage = calculateExtendedLevergae();
     const latestPosition = (await client.getPositions()).data.pop();
     if (!extendedHoldings || !latestPosition) {
-      logger.error(`error getting extended position: extendedHoldings=${extendedHoldings}, latestPosition=${latestPosition}`);
+      logger.error(
+        `error getting extended position: extendedHoldings=${extendedHoldings}, latestPosition=${latestPosition}`
+      );
       return null;
     }
-    const positionValueInUSD = new Web3Number(latestPosition.value, USDC_TOKEN_DECIMALS);
+    const positionValueInUSD = new Web3Number(
+      latestPosition.value,
+      USDC_TOKEN_DECIMALS
+    );
     const equity = extendedHoldings.data.equity;
     const deposit = positionValueInUSD.dividedBy(extended_leverage).minus(equity).toFixed(2);
     return new Web3Number(deposit, USDC_TOKEN_DECIMALS);
   } catch (err) {
-    logger.error(`error calculating amount deposit on extended when incurring losses: ${err}`);
+    logger.error(
+      `error calculating amount deposit on extended when incurring losses: ${err}`
+    );
     return null;
   }
 };
@@ -28592,6 +28601,26 @@ var calculateDeltaDebtAmount = (maxLtv = MAX_LTV_BTC_USDC, existingVesuCollatera
     return null;
   }
 };
+var calculatePositionToCloseToWithdrawAmount = async (extendedBalance, extendedPositions, amountToWithdraw) => {
+  try {
+    const extendedLeverage = calculateExtendedLevergae();
+    const extendedPosition = extendedPositions.value;
+    const marginRequired = new Web3Number(extendedBalance.initialMargin, USDC_TOKEN_DECIMALS);
+    const unrealisedPnl = new Web3Number(extendedBalance.unrealisedPnl, USDC_TOKEN_DECIMALS);
+    const availableForWithdrawal = new Web3Number(extendedBalance.availableForWithdrawal, USDC_TOKEN_DECIMALS);
+    const upnlPercent = unrealisedPnl.dividedBy(extendedPosition);
+    console.log(`upnlPercent: ${upnlPercent}`);
+    const walletBalance = new Web3Number(extendedBalance.balance, USDC_TOKEN_DECIMALS);
+    const term1 = marginRequired.minus(walletBalance).minus(availableForWithdrawal).plus(amountToWithdraw).multipliedBy(extendedLeverage);
+    const denominator = upnlPercent.multipliedBy(extendedLeverage).plus(1);
+    return new Web3Number(Math.ceil(term1.dividedBy(denominator).dividedBy(extendedLeverage).toNumber()), USDC_TOKEN_DECIMALS);
+  } catch (err) {
+    logger.error(
+      `error calculating position to close to withdraw amount: ${err}`
+    );
+    return new Web3Number(0, USDC_TOKEN_DECIMALS);
+  }
+};
 
 // src/utils/health-factor-math.ts
 var HealthFactorMath = class {
@@ -35187,6 +35216,19 @@ var VesuExtendedMultiplierStrategy = class _VesuExtendedMultiplierStrategy exten
         logger.info(
           `${_VesuExtendedMultiplierStrategy.name}::moveAssets extendedHoldingAmount: ${extendedHoldingAmount.toNumber()}`
         );
+        const extendedPositions = await extendedAdapter.getAllOpenPositions();
+        if (!extendedPositions) {
+          logger.error(
+            `error getting extended positions: ${extendedPositions} while moving assets from extended to vault`
+          );
+          return this.createTransactionResult(
+            [],
+            false,
+            params,
+            "NONE",
+            params.cycleType
+          );
+        }
         if (params.amount.abs().greaterThan(extendedHoldingAmount)) {
           const leftAmountAfterWithdrawalAmountInAccount = new Web3Number(
             Math.ceil(
@@ -35194,6 +35236,14 @@ var VesuExtendedMultiplierStrategy = class _VesuExtendedMultiplierStrategy exten
             ),
             USDC_TOKEN_DECIMALS
           );
+          const positionAmountToClose = await calculatePositionToCloseToWithdrawAmount(
+            extendedHoldings,
+            extendedPositions[0],
+            params.amount
+          );
+          logger.info(
+            `positionAmountToClose: ${positionAmountToClose} this is without leverage`
+          );
           logger.info(
             `${_VesuExtendedMultiplierStrategy.name}::moveAssets leftAmountAfterWithdrawalAmountInAccount: ${leftAmountAfterWithdrawalAmountInAccount.toNumber()}`
           );
@@ -35206,7 +35256,7 @@ var VesuExtendedMultiplierStrategy = class _VesuExtendedMultiplierStrategy exten
             logger.error(`error fetching order book btc usdc: ${status}`);
             priceOfBTC = collateralPrice.price;
           }
-          const btcAmount = leftAmountAfterWithdrawalAmountInAccount.dividedBy(priceOfBTC);
+          const btcAmount = positionAmountToClose.dividedBy(priceOfBTC);
           const openLongPosition = btcAmount.multipliedBy(3).greaterThan(MINIMUM_EXTENDED_POSITION_SIZE) ? await extendedAdapter.createOrder(
             extendedLeverage.toString(),
             btcAmount.toNumber(),
@@ -39988,6 +40038,7 @@ export {
   calculateDeltaDebtAmount,
   calculateExposureDelta,
   calculateExtendedLevergae,
+  calculatePositionToCloseToWithdrawAmount,
   calculateVesUPositionSizeGivenExtended,
   calculateVesuLeverage,
   calculateWBTCAmountToMaintainLTV,

package/dist/index.d.ts

@@ -2800,6 +2800,7 @@ declare const calculateVesUPositionSizeGivenExtended: (extendedPositonValue: num
  * @returns The debt amount to be repaid
  */
 declare const calculateDeltaDebtAmount: (maxLtv: number | undefined, existingVesuCollateral: Web3Number, existingVesuDebt: Web3Number, collateralPrice: number, debtPrice: number, targetHf?: number) => Web3Number | null;
+declare const calculatePositionToCloseToWithdrawAmount: (extendedBalance: Balance, extendedPositions: Position, amountToWithdraw: Web3Number) => Promise<Web3Number>;
 
 interface EkuboRouteNode {
     pool_key: {
@@ -3146,4 +3147,4 @@ declare class PasswordJsonCryptoUtil {
     decrypt(encryptedData: string, password: string): any;
 }
 
-export { type APYInfo, APYType, AUDIT_URL, AUMTypes, AVNU_EXCHANGE, AVNU_EXCHANGE_FOR_LEGACY_USDC, AVNU_LEGACY_SANITIZER, AVNU_MIDDLEWARE, AVNU_QUOTE_URL, AbisConfig, type AccountInfo, type AdapterLeafType, AddressesConfig, type AllAccountsStore, type ApiResponse, type ApproveCallParams, type AssetOperation, AssetOperationStatus, AssetOperationType, AutoCompounderSTRK, AvnuAdapter, type AvnuAdapterConfig, type AvnuSwapCallParams, AvnuWrapper, type Balance, BaseAdapter, type BaseAdapterConfig, BaseStrategy, type CLVaultStrategySettings, type CancelOrderRequest, CommonAdapter, type CommonAdapterConfig, ContractAddr, type CreateOrderRequest, CycleType, type DecreaseLeverParams, Deployer, type DepositParams, type DualActionAmount, type DualTokenInfo, ERC20, EXTENDED_CONTRACT, EXTENDED_SANITIZER, type EkuboBounds, EkuboCLVault, EkuboCLVaultStrategies, type EkuboPoolKey, type EkuboQuote, EkuboQuoter, type EkuboRouteNode, type EkuboSplit, ExitType, ExtendedAdapter, type ExtendedAdapterConfig, type ExtendedApiResponse, ExtendedConfig, ExtendedWrapper, type ExtendedWrapperConfig, type FAQ, FatalError, type FlashloanCallParams, FlowChartColors, type FundingRate, type GenerateCallFn, Global, HyperLSTStrategies, type HyperLSTStrategySettings, type IConfig, type IInvestmentFlow, ILending, type ILendingMetadata, type ILendingPosition, type IProtocol, type IStrategyMetadata, type IncreaseLeverParams, Initializable, type L2Config, LSTAPRService, type LSTStats, type LeafAdapterFn, type LeafData, type LendingToken, type ManageCall, MarginType, type Market, type MarketStats, Midas, Network, type OpenOrder, OrderSide, OrderStatus, OrderStatusReason, OrderType, PRICE_ROUTER, PasswordJsonCryptoUtil, type PlacedOrder, type Position, type PositionAPY, type PositionAmount, type PositionHistory, type PositionInfo, PositionSide, PositionTypeAvnuExtended, Pragma, type PriceInfo, Pricer, PricerBase, PricerFromApi, PricerLST, PricerRedis, Protocols, type RequiredFields, type RequiredKeys, type RequiredStoreConfig, type RiskFactor, type RiskFactorConfig, RiskType, type Route, type RouteNode, SIMPLE_SANITIZER, SIMPLE_SANITIZER_V2, SIMPLE_SANITIZER_VESU_V1_DELEGATIONS, SenseiStrategies, SenseiVault, type SenseiVaultSettings, type SettlementSignature, type SignedWithdrawRequest, type SingleActionAmount, type SingleTokenInfo, StandardMerkleTree, type StandardMerkleTreeData, type StarkDebuggingOrderAmounts, type StarkSettlement, Store, type StoreConfig, type SupportedPosition, type Swap, type SwapInfo, TelegramGroupNotif, TelegramNotif, TimeInForce, type TokenAmount, type TokenInfo, TokenMarketData, type TradingConfig, type TransactionMetadata, type TransactionResult, UNIVERSAL_MANAGE_IDS, UniversalLstMultiplierStrategy, type UniversalManageCall, type UniversalStrategySettings, UnusedBalanceAdapter, type UnusedBalanceAdapterConfig, type UpdateLeverageRequest, VESU_SINGLETON, VESU_V2_MODIFY_POSITION_SANITIZER, type VaultPosition, VesuAdapter, type VesuAdapterConfig, type VesuAmount, VesuAmountDenomination, VesuAmountType, VesuConfig, type VesuDefiSpringRewardsCallParams, VesuExtendedMultiplierStrategy, type VesuExtendedStrategySettings, VesuExtendedTestStrategies, type VesuModifyDelegationCallParams, type VesuModifyPositionCallParams, VesuMultiplyAdapter, type VesuMultiplyAdapterConfig, type VesuMultiplyCallParams, VesuPools, VesuRebalance, type VesuRebalanceSettings, VesuRebalanceStrategies, VesuSupplyOnlyAdapter, type VesuSupplyOnlyAdapterConfig, Web3Number, type WithdrawParams, type WithdrawRequest, ZkLend, _riskFactor, assert, calculateAmountDepositOnExtendedWhenIncurringLosses, calculateAmountDistribution, calculateAmountDistributionForWithdrawal, calculateBTCPriceDelta, calculateDebtAmount, calculateDebtReductionAmountForWithdrawal, calculateDeltaDebtAmount, calculateExposureDelta, calculateExtendedLevergae, calculateVesUPositionSizeGivenExtended, calculateVesuLeverage, calculateWBTCAmountToMaintainLTV, extensionMap, getAPIUsingHeadlessBrowser, getContractDetails, getDefaultStoreConfig, getFAQs, getInvestmentSteps, getMainnetConfig, getNoRiskTags, getRiskColor, getRiskExplaination, getTrovesEndpoint, getVesuSingletonAddress, highlightTextWithLinks, type i257, logger, returnFormattedAmount, toBigInt };
+export { type APYInfo, APYType, AUDIT_URL, AUMTypes, AVNU_EXCHANGE, AVNU_EXCHANGE_FOR_LEGACY_USDC, AVNU_LEGACY_SANITIZER, AVNU_MIDDLEWARE, AVNU_QUOTE_URL, AbisConfig, type AccountInfo, type AdapterLeafType, AddressesConfig, type AllAccountsStore, type ApiResponse, type ApproveCallParams, type AssetOperation, AssetOperationStatus, AssetOperationType, AutoCompounderSTRK, AvnuAdapter, type AvnuAdapterConfig, type AvnuSwapCallParams, AvnuWrapper, type Balance, BaseAdapter, type BaseAdapterConfig, BaseStrategy, type CLVaultStrategySettings, type CancelOrderRequest, CommonAdapter, type CommonAdapterConfig, ContractAddr, type CreateOrderRequest, CycleType, type DecreaseLeverParams, Deployer, type DepositParams, type DualActionAmount, type DualTokenInfo, ERC20, EXTENDED_CONTRACT, EXTENDED_SANITIZER, type EkuboBounds, EkuboCLVault, EkuboCLVaultStrategies, type EkuboPoolKey, type EkuboQuote, EkuboQuoter, type EkuboRouteNode, type EkuboSplit, ExitType, ExtendedAdapter, type ExtendedAdapterConfig, type ExtendedApiResponse, ExtendedConfig, ExtendedWrapper, type ExtendedWrapperConfig, type FAQ, FatalError, type FlashloanCallParams, FlowChartColors, type FundingRate, type GenerateCallFn, Global, HyperLSTStrategies, type HyperLSTStrategySettings, type IConfig, type IInvestmentFlow, ILending, type ILendingMetadata, type ILendingPosition, type IProtocol, type IStrategyMetadata, type IncreaseLeverParams, Initializable, type L2Config, LSTAPRService, type LSTStats, type LeafAdapterFn, type LeafData, type LendingToken, type ManageCall, MarginType, type Market, type MarketStats, Midas, Network, type OpenOrder, OrderSide, OrderStatus, OrderStatusReason, OrderType, PRICE_ROUTER, PasswordJsonCryptoUtil, type PlacedOrder, type Position, type PositionAPY, type PositionAmount, type PositionHistory, type PositionInfo, PositionSide, PositionTypeAvnuExtended, Pragma, type PriceInfo, Pricer, PricerBase, PricerFromApi, PricerLST, PricerRedis, Protocols, type RequiredFields, type RequiredKeys, type RequiredStoreConfig, type RiskFactor, type RiskFactorConfig, RiskType, type Route, type RouteNode, SIMPLE_SANITIZER, SIMPLE_SANITIZER_V2, SIMPLE_SANITIZER_VESU_V1_DELEGATIONS, SenseiStrategies, SenseiVault, type SenseiVaultSettings, type SettlementSignature, type SignedWithdrawRequest, type SingleActionAmount, type SingleTokenInfo, StandardMerkleTree, type StandardMerkleTreeData, type StarkDebuggingOrderAmounts, type StarkSettlement, Store, type StoreConfig, type SupportedPosition, type Swap, type SwapInfo, TelegramGroupNotif, TelegramNotif, TimeInForce, type TokenAmount, type TokenInfo, TokenMarketData, type TradingConfig, type TransactionMetadata, type TransactionResult, UNIVERSAL_MANAGE_IDS, UniversalLstMultiplierStrategy, type UniversalManageCall, type UniversalStrategySettings, UnusedBalanceAdapter, type UnusedBalanceAdapterConfig, type UpdateLeverageRequest, VESU_SINGLETON, VESU_V2_MODIFY_POSITION_SANITIZER, type VaultPosition, VesuAdapter, type VesuAdapterConfig, type VesuAmount, VesuAmountDenomination, VesuAmountType, VesuConfig, type VesuDefiSpringRewardsCallParams, VesuExtendedMultiplierStrategy, type VesuExtendedStrategySettings, VesuExtendedTestStrategies, type VesuModifyDelegationCallParams, type VesuModifyPositionCallParams, VesuMultiplyAdapter, type VesuMultiplyAdapterConfig, type VesuMultiplyCallParams, VesuPools, VesuRebalance, type VesuRebalanceSettings, VesuRebalanceStrategies, VesuSupplyOnlyAdapter, type VesuSupplyOnlyAdapterConfig, Web3Number, type WithdrawParams, type WithdrawRequest, ZkLend, _riskFactor, assert, calculateAmountDepositOnExtendedWhenIncurringLosses, calculateAmountDistribution, calculateAmountDistributionForWithdrawal, calculateBTCPriceDelta, calculateDebtAmount, calculateDebtReductionAmountForWithdrawal, calculateDeltaDebtAmount, calculateExposureDelta, calculateExtendedLevergae, calculatePositionToCloseToWithdrawAmount, calculateVesUPositionSizeGivenExtended, calculateVesuLeverage, calculateWBTCAmountToMaintainLTV, extensionMap, getAPIUsingHeadlessBrowser, getContractDetails, getDefaultStoreConfig, getFAQs, getInvestmentSteps, getMainnetConfig, getNoRiskTags, getRiskColor, getRiskExplaination, getTrovesEndpoint, getVesuSingletonAddress, highlightTextWithLinks, type i257, logger, returnFormattedAmount, toBigInt };

package/dist/index.js

@@ -127,6 +127,7 @@ __export(index_exports, {
   calculateDeltaDebtAmount: () => calculateDeltaDebtAmount,
   calculateExposureDelta: () => calculateExposureDelta,
   calculateExtendedLevergae: () => calculateExtendedLevergae,
+  calculatePositionToCloseToWithdrawAmount: () => calculatePositionToCloseToWithdrawAmount,
   calculateVesUPositionSizeGivenExtended: () => calculateVesUPositionSizeGivenExtended,
   calculateVesuLeverage: () => calculateVesuLeverage,
   calculateWBTCAmountToMaintainLTV: () => calculateWBTCAmountToMaintainLTV,
@@ -28282,7 +28283,9 @@ var calculateAmountDistributionForWithdrawal = async (amountInUsdc, collateralPr
       vesu_leverage
     };
   } catch (err) {
-    logger.error(`error calculating amount distribution for withdrawal: ${err}`);
+    logger.error(
+      `error calculating amount distribution for withdrawal: ${err}`
+    );
     return null;
   }
 };
@@ -28335,15 +28338,22 @@ var calculateAmountDepositOnExtendedWhenIncurringLosses = async (client) => {
     const extended_leverage = calculateExtendedLevergae();
     const latestPosition = (await client.getPositions()).data.pop();
     if (!extendedHoldings || !latestPosition) {
-      logger.error(`error getting extended position: extendedHoldings=${extendedHoldings}, latestPosition=${latestPosition}`);
+      logger.error(
+        `error getting extended position: extendedHoldings=${extendedHoldings}, latestPosition=${latestPosition}`
+      );
       return null;
     }
-    const positionValueInUSD = new Web3Number(latestPosition.value, USDC_TOKEN_DECIMALS);
+    const positionValueInUSD = new Web3Number(
+      latestPosition.value,
+      USDC_TOKEN_DECIMALS
+    );
     const equity = extendedHoldings.data.equity;
     const deposit = positionValueInUSD.dividedBy(extended_leverage).minus(equity).toFixed(2);
     return new Web3Number(deposit, USDC_TOKEN_DECIMALS);
   } catch (err) {
-    logger.error(`error calculating amount deposit on extended when incurring losses: ${err}`);
+    logger.error(
+      `error calculating amount deposit on extended when incurring losses: ${err}`
+    );
     return null;
   }
 };
@@ -28395,6 +28405,26 @@ var calculateDeltaDebtAmount = (maxLtv = MAX_LTV_BTC_USDC, existingVesuCollatera
     return null;
   }
 };
+var calculatePositionToCloseToWithdrawAmount = async (extendedBalance, extendedPositions, amountToWithdraw) => {
+  try {
+    const extendedLeverage = calculateExtendedLevergae();
+    const extendedPosition = extendedPositions.value;
+    const marginRequired = new Web3Number(extendedBalance.initialMargin, USDC_TOKEN_DECIMALS);
+    const unrealisedPnl = new Web3Number(extendedBalance.unrealisedPnl, USDC_TOKEN_DECIMALS);
+    const availableForWithdrawal = new Web3Number(extendedBalance.availableForWithdrawal, USDC_TOKEN_DECIMALS);
+    const upnlPercent = unrealisedPnl.dividedBy(extendedPosition);
+    console.log(`upnlPercent: ${upnlPercent}`);
+    const walletBalance = new Web3Number(extendedBalance.balance, USDC_TOKEN_DECIMALS);
+    const term1 = marginRequired.minus(walletBalance).minus(availableForWithdrawal).plus(amountToWithdraw).multipliedBy(extendedLeverage);
+    const denominator = upnlPercent.multipliedBy(extendedLeverage).plus(1);
+    return new Web3Number(Math.ceil(term1.dividedBy(denominator).dividedBy(extendedLeverage).toNumber()), USDC_TOKEN_DECIMALS);
+  } catch (err) {
+    logger.error(
+      `error calculating position to close to withdraw amount: ${err}`
+    );
+    return new Web3Number(0, USDC_TOKEN_DECIMALS);
+  }
+};
 
 // src/utils/health-factor-math.ts
 var HealthFactorMath = class {
@@ -35345,6 +35375,19 @@ var VesuExtendedMultiplierStrategy = class _VesuExtendedMultiplierStrategy exten
         logger.info(
           `${_VesuExtendedMultiplierStrategy.name}::moveAssets extendedHoldingAmount: ${extendedHoldingAmount.toNumber()}`
         );
+        const extendedPositions = await extendedAdapter.getAllOpenPositions();
+        if (!extendedPositions) {
+          logger.error(
+            `error getting extended positions: ${extendedPositions} while moving assets from extended to vault`
+          );
+          return this.createTransactionResult(
+            [],
+            false,
+            params,
+            "NONE",
+            params.cycleType
+          );
+        }
         if (params.amount.abs().greaterThan(extendedHoldingAmount)) {
           const leftAmountAfterWithdrawalAmountInAccount = new Web3Number(
             Math.ceil(
@@ -35352,6 +35395,14 @@ var VesuExtendedMultiplierStrategy = class _VesuExtendedMultiplierStrategy exten
             ),
             USDC_TOKEN_DECIMALS
           );
+          const positionAmountToClose = await calculatePositionToCloseToWithdrawAmount(
+            extendedHoldings,
+            extendedPositions[0],
+            params.amount
+          );
+          logger.info(
+            `positionAmountToClose: ${positionAmountToClose} this is without leverage`
+          );
           logger.info(
             `${_VesuExtendedMultiplierStrategy.name}::moveAssets leftAmountAfterWithdrawalAmountInAccount: ${leftAmountAfterWithdrawalAmountInAccount.toNumber()}`
           );
@@ -35364,7 +35415,7 @@ var VesuExtendedMultiplierStrategy = class _VesuExtendedMultiplierStrategy exten
             logger.error(`error fetching order book btc usdc: ${status}`);
             priceOfBTC = collateralPrice.price;
           }
-          const btcAmount = leftAmountAfterWithdrawalAmountInAccount.dividedBy(priceOfBTC);
+          const btcAmount = positionAmountToClose.dividedBy(priceOfBTC);
           const openLongPosition = btcAmount.multipliedBy(3).greaterThan(MINIMUM_EXTENDED_POSITION_SIZE) ? await extendedAdapter.createOrder(
             extendedLeverage.toString(),
             btcAmount.toNumber(),
@@ -40713,6 +40764,7 @@ var deployer_default = Deployer;
   calculateDeltaDebtAmount,
   calculateExposureDelta,
   calculateExtendedLevergae,
+  calculatePositionToCloseToWithdrawAmount,
   calculateVesUPositionSizeGivenExtended,
   calculateVesuLeverage,
   calculateWBTCAmountToMaintainLTV,

package/dist/index.mjs

@@ -28135,7 +28135,9 @@ var calculateAmountDistributionForWithdrawal = async (amountInUsdc, collateralPr
       vesu_leverage
     };
   } catch (err) {
-    logger.error(`error calculating amount distribution for withdrawal: ${err}`);
+    logger.error(
+      `error calculating amount distribution for withdrawal: ${err}`
+    );
     return null;
   }
 };
@@ -28188,15 +28190,22 @@ var calculateAmountDepositOnExtendedWhenIncurringLosses = async (client) => {
     const extended_leverage = calculateExtendedLevergae();
     const latestPosition = (await client.getPositions()).data.pop();
     if (!extendedHoldings || !latestPosition) {
-      logger.error(`error getting extended position: extendedHoldings=${extendedHoldings}, latestPosition=${latestPosition}`);
+      logger.error(
+        `error getting extended position: extendedHoldings=${extendedHoldings}, latestPosition=${latestPosition}`
+      );
       return null;
     }
-    const positionValueInUSD = new Web3Number(latestPosition.value, USDC_TOKEN_DECIMALS);
+    const positionValueInUSD = new Web3Number(
+      latestPosition.value,
+      USDC_TOKEN_DECIMALS
+    );
     const equity = extendedHoldings.data.equity;
     const deposit = positionValueInUSD.dividedBy(extended_leverage).minus(equity).toFixed(2);
     return new Web3Number(deposit, USDC_TOKEN_DECIMALS);
   } catch (err) {
-    logger.error(`error calculating amount deposit on extended when incurring losses: ${err}`);
+    logger.error(
+      `error calculating amount deposit on extended when incurring losses: ${err}`
+    );
     return null;
   }
 };
@@ -28248,6 +28257,26 @@ var calculateDeltaDebtAmount = (maxLtv = MAX_LTV_BTC_USDC, existingVesuCollatera
     return null;
   }
 };
+var calculatePositionToCloseToWithdrawAmount = async (extendedBalance, extendedPositions, amountToWithdraw) => {
+  try {
+    const extendedLeverage = calculateExtendedLevergae();
+    const extendedPosition = extendedPositions.value;
+    const marginRequired = new Web3Number(extendedBalance.initialMargin, USDC_TOKEN_DECIMALS);
+    const unrealisedPnl = new Web3Number(extendedBalance.unrealisedPnl, USDC_TOKEN_DECIMALS);
+    const availableForWithdrawal = new Web3Number(extendedBalance.availableForWithdrawal, USDC_TOKEN_DECIMALS);
+    const upnlPercent = unrealisedPnl.dividedBy(extendedPosition);
+    console.log(`upnlPercent: ${upnlPercent}`);
+    const walletBalance = new Web3Number(extendedBalance.balance, USDC_TOKEN_DECIMALS);
+    const term1 = marginRequired.minus(walletBalance).minus(availableForWithdrawal).plus(amountToWithdraw).multipliedBy(extendedLeverage);
+    const denominator = upnlPercent.multipliedBy(extendedLeverage).plus(1);
+    return new Web3Number(Math.ceil(term1.dividedBy(denominator).dividedBy(extendedLeverage).toNumber()), USDC_TOKEN_DECIMALS);
+  } catch (err) {
+    logger.error(
+      `error calculating position to close to withdraw amount: ${err}`
+    );
+    return new Web3Number(0, USDC_TOKEN_DECIMALS);
+  }
+};
 
 // src/utils/health-factor-math.ts
 var HealthFactorMath = class {
@@ -35198,6 +35227,19 @@ var VesuExtendedMultiplierStrategy = class _VesuExtendedMultiplierStrategy exten
         logger.info(
           `${_VesuExtendedMultiplierStrategy.name}::moveAssets extendedHoldingAmount: ${extendedHoldingAmount.toNumber()}`
         );
+        const extendedPositions = await extendedAdapter.getAllOpenPositions();
+        if (!extendedPositions) {
+          logger.error(
+            `error getting extended positions: ${extendedPositions} while moving assets from extended to vault`
+          );
+          return this.createTransactionResult(
+            [],
+            false,
+            params,
+            "NONE",
+            params.cycleType
+          );
+        }
         if (params.amount.abs().greaterThan(extendedHoldingAmount)) {
           const leftAmountAfterWithdrawalAmountInAccount = new Web3Number(
             Math.ceil(
@@ -35205,6 +35247,14 @@ var VesuExtendedMultiplierStrategy = class _VesuExtendedMultiplierStrategy exten
             ),
             USDC_TOKEN_DECIMALS
           );
+          const positionAmountToClose = await calculatePositionToCloseToWithdrawAmount(
+            extendedHoldings,
+            extendedPositions[0],
+            params.amount
+          );
+          logger.info(
+            `positionAmountToClose: ${positionAmountToClose} this is without leverage`
+          );
           logger.info(
             `${_VesuExtendedMultiplierStrategy.name}::moveAssets leftAmountAfterWithdrawalAmountInAccount: ${leftAmountAfterWithdrawalAmountInAccount.toNumber()}`
           );
@@ -35217,7 +35267,7 @@ var VesuExtendedMultiplierStrategy = class _VesuExtendedMultiplierStrategy exten
             logger.error(`error fetching order book btc usdc: ${status}`);
             priceOfBTC = collateralPrice.price;
           }
-          const btcAmount = leftAmountAfterWithdrawalAmountInAccount.dividedBy(priceOfBTC);
+          const btcAmount = positionAmountToClose.dividedBy(priceOfBTC);
           const openLongPosition = btcAmount.multipliedBy(3).greaterThan(MINIMUM_EXTENDED_POSITION_SIZE) ? await extendedAdapter.createOrder(
             extendedLeverage.toString(),
             btcAmount.toNumber(),
@@ -40565,6 +40615,7 @@ export {
   calculateDeltaDebtAmount,
   calculateExposureDelta,
   calculateExtendedLevergae,
+  calculatePositionToCloseToWithdrawAmount,
   calculateVesUPositionSizeGivenExtended,
   calculateVesuLeverage,
   calculateWBTCAmountToMaintainLTV,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@strkfarm/sdk",
-  "version": "2.0.0-dev.23",
+  "version": "2.0.0-dev.25",
   "description": "STRKFarm TS SDK (Meant for our internal use, but feel free to use it)",
   "typings": "dist/index.d.ts",
   "types": "dist/index.d.ts",

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

@@ -9,6 +9,8 @@ import {
   USDC_TOKEN_DECIMALS,
   MAX_LIQUIDATION_RATIO,
 } from "./constants";
+import { ExtendedAdapter } from "../../universal-adapters/extended-adapter";
+import { Balance } from "@/modules/ExtendedWrapperSDk";
 import { Web3Number } from "@/dataTypes";
 import { Position } from "@/modules/ExtendedWrapperSDk";
 // import { getAllOpenPositionsExtended } from "../services/extendedService";
@@ -126,9 +128,9 @@ export const calculateAmountDistributionForWithdrawal = async (
       return null;
     }
     const extendedExposureUSD =
-    extendedPosition.length > 0
-    ? new Web3Number(extendedPosition[0].value, USDC_TOKEN_DECIMALS)
-    : new Web3Number(0, USDC_TOKEN_DECIMALS);
+      extendedPosition.length > 0
+        ? new Web3Number(extendedPosition[0].value, USDC_TOKEN_DECIMALS)
+        : new Web3Number(0, USDC_TOKEN_DECIMALS);
     const vesuExposureUSD = collateralUnits.multipliedBy(collateralPrice);
     if (vesuExposureUSD.lessThan(0)) {
       return {
@@ -153,8 +155,7 @@ export const calculateAmountDistributionForWithdrawal = async (
     console.log("the vesu leverage is", vesu_leverage);
     const numerator1 = amountInUsdc.multipliedBy(extended_leverage);
     const numerator2 = vesuExposureUSD;
-    const numerator3 = extendedExposureUSD
-      .multipliedBy(-1);
+    const numerator3 = extendedExposureUSD.multipliedBy(-1);
     const finalNumerator = numerator1.plus(numerator2).plus(numerator3);
     const denominator = extended_leverage + vesu_leverage;
     const vesuAmountInUSDC = finalNumerator.dividedBy(denominator);
@@ -174,7 +175,9 @@ export const calculateAmountDistributionForWithdrawal = async (
       vesu_leverage,
     };
   } catch (err) {
-    logger.error(`error calculating amount distribution for withdrawal: ${err}`);
+    logger.error(
+      `error calculating amount distribution for withdrawal: ${err}`
+    );
     return null;
   }
 };
@@ -226,8 +229,8 @@ export const calculateDebtAmount = (
   try {
     // => X = (((collateral + legDepositAmount) * collateralPrice * ltv) - (debt * debtPrice * target hf)) / (target hf - ltv)
     const addedCollateral = addedAmount.multipliedBy(isDeposit ? 1 : -1);
-    const numerator1 = (collateralAmount
-      .plus(addedCollateral))
+    const numerator1 = collateralAmount
+      .plus(addedCollateral)
       .multipliedBy(collateralPrice)
       .multipliedBy(maxLtv);
     const numerator2 = debtAmount
@@ -304,15 +307,25 @@ export const calculateAmountDepositOnExtendedWhenIncurringLosses = async (
     const extended_leverage = calculateExtendedLevergae();
     const latestPosition = (await client.getPositions()).data.pop();
     if (!extendedHoldings || !latestPosition) {
-      logger.error(`error getting extended position: extendedHoldings=${extendedHoldings}, latestPosition=${latestPosition}`);
+      logger.error(
+        `error getting extended position: extendedHoldings=${extendedHoldings}, latestPosition=${latestPosition}`
+      );
       return null;
     }
-    const positionValueInUSD = new Web3Number(latestPosition.value, USDC_TOKEN_DECIMALS);
+    const positionValueInUSD = new Web3Number(
+      latestPosition.value,
+      USDC_TOKEN_DECIMALS
+    );
     const equity = extendedHoldings.data.equity;
-    const deposit = positionValueInUSD.dividedBy(extended_leverage).minus(equity).toFixed(2);
+    const deposit = positionValueInUSD
+      .dividedBy(extended_leverage)
+      .minus(equity)
+      .toFixed(2);
     return new Web3Number(deposit, USDC_TOKEN_DECIMALS);
   } catch (err) {
-    logger.error(`error calculating amount deposit on extended when incurring losses: ${err}`);
+    logger.error(
+      `error calculating amount deposit on extended when incurring losses: ${err}`
+    );
     return null;
   }
 };
@@ -324,9 +337,9 @@ export const calculateAmountDepositOnExtendedWhenIncurringLosses = async (
  * @param collateralAmount in collateral units
  * @param debtAmount in debt units
  * @param debtPrice in usd
- * @param maxLtv 
+ * @param maxLtv
  * @param collateralPrice in usd
- * @param targetHF 
+ * @param targetHF
  * @returns deltaCollateralAmountUnits in collateral units
  *          null if there is an error
  */
@@ -336,26 +349,30 @@ export const calculateWBTCAmountToMaintainLTV = (
   debtPrice: number,
   maxLtv: number = MAX_LIQUIDATION_RATIO,
   collateralPrice: number,
-  targetHF: number = TARGET_HF,
-) =>{
+  targetHF: number = TARGET_HF
+) => {
   try {
-    const numerator1 = (collateralAmount)
+    const numerator1 = collateralAmount
       .multipliedBy(collateralPrice)
-      .multipliedBy(maxLtv)
+      .multipliedBy(maxLtv);
     const numerator2 = debtAmount
       .multipliedBy(debtPrice)
       .multipliedBy(targetHF);
     const denominator = maxLtv;
-    const collateralAmountToMaintainLTV = numerator2.minus(numerator1).dividedBy(denominator);
+    const collateralAmountToMaintainLTV = numerator2
+      .minus(numerator1)
+      .dividedBy(denominator);
     let deltaCollateralAmountUnits = new Web3Number(
-      collateralAmountToMaintainLTV.dividedBy(collateralPrice).toFixed(WBTC_TOKEN_DECIMALS),
+      collateralAmountToMaintainLTV
+        .dividedBy(collateralPrice)
+        .toFixed(WBTC_TOKEN_DECIMALS),
       WBTC_TOKEN_DECIMALS
     );
-    return {deltaCollateralAmountUnits};
+    return { deltaCollateralAmountUnits };
   } catch (err) {
     return { deltaCollateralAmountUnits: null };
   }
-}
+};
 
 export const calculateExposureDelta = (
   exposure_extended: number,
@@ -392,14 +409,17 @@ export const calculateVesUPositionSizeGivenExtended = (
   const extendedLeverage = calculateExtendedLevergae();
   const vesuLeverage = calculateVesuLeverage();
   const extendedAmount = extendedHoldingAmount;
-  const extendedAmountInBTC = extendedAmount
-    .dividedBy(collateralPrice)
-  const numerator1 = extendedAmount.multipliedBy(extendedLeverage)
-    .plus(extendedPositonValue)
+  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).plus(vesuDebtAmountToBeRepaid);
+  const vesuAmountInUsd = numerator1
+    .plus(numerator2)
+    .dividedBy(vesuLeverage)
+    .plus(vesuDebtAmountToBeRepaid);
   const vesuAmountInBTC = vesuAmountInUsd
     .dividedBy(collateralPrice)
     .toFixed(WBTC_TOKEN_DECIMALS);
@@ -422,19 +442,53 @@ export const calculateVesUPositionSizeGivenExtended = (
  */
 export const calculateDeltaDebtAmount = (
   maxLtv: number = MAX_LTV_BTC_USDC,
-  existingVesuCollateral: Web3Number, 
+  existingVesuCollateral: Web3Number,
   existingVesuDebt: Web3Number,
   collateralPrice: number,
   debtPrice: number,
-  targetHf: number = TARGET_HF,
+  targetHf: number = TARGET_HF
 ) => {
   try {
-    const term1 = existingVesuCollateral.multipliedBy(collateralPrice).multipliedBy(maxLtv).dividedBy(targetHf);
-    const term2 = existingVesuDebt.multipliedBy(debtPrice).multipliedBy(targetHf).multipliedBy(-1);
+    const term1 = existingVesuCollateral
+      .multipliedBy(collateralPrice)
+      .multipliedBy(maxLtv)
+      .dividedBy(targetHf);
+    const term2 = existingVesuDebt
+      .multipliedBy(debtPrice)
+      .multipliedBy(targetHf)
+      .multipliedBy(-1);
     const debtAmountToBeRepaid = term1.plus(term2).dividedBy(targetHf);
     return debtAmountToBeRepaid;
   } catch (err) {
     logger.error(`error calculating delta position: ${err}`);
     return null;
   }
-};
+};
+
+export const calculatePositionToCloseToWithdrawAmount = async (
+  extendedBalance: Balance,
+  extendedPositions: Position,
+  amountToWithdraw: Web3Number
+) => {
+  try {
+    const extendedLeverage = calculateExtendedLevergae();
+    const extendedPosition = extendedPositions.value;
+    const marginRequired = new Web3Number(extendedBalance.initialMargin , USDC_TOKEN_DECIMALS);
+    const unrealisedPnl = new Web3Number(extendedBalance.unrealisedPnl, USDC_TOKEN_DECIMALS);
+    const availableForWithdrawal = new Web3Number(extendedBalance.availableForWithdrawal, USDC_TOKEN_DECIMALS);
+    const upnlPercent = unrealisedPnl.dividedBy(extendedPosition)
+    console.log(`upnlPercent: ${upnlPercent}`);
+    /**
+     * New Formula
+     */
+    const walletBalance = new Web3Number(extendedBalance.balance, USDC_TOKEN_DECIMALS);
+    const term1 = marginRequired.minus(walletBalance).minus(availableForWithdrawal).plus(amountToWithdraw).multipliedBy(extendedLeverage);
+    const denominator = upnlPercent.multipliedBy(extendedLeverage).plus(1);
+    return new Web3Number(Math.ceil(term1.dividedBy(denominator).dividedBy(extendedLeverage).toNumber()), USDC_TOKEN_DECIMALS);
+  } catch (err) {
+    logger.error(
+      `error calculating position to close to withdraw amount: ${err}`
+    );
+    return new Web3Number(0, USDC_TOKEN_DECIMALS);
+  }
+};

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

@@ -8,7 +8,12 @@ import {
   UNIVERSAL_MANAGE_IDS,
   UniversalStrategySettings,
 } from "../universal-strategy";
-import { calculateDebtAmount, calculateDeltaDebtAmount, calculateExtendedLevergae } from "./utils/helper";
+import {
+  calculateDebtAmount,
+  calculateDeltaDebtAmount,
+  calculateExtendedLevergae,
+  calculatePositionToCloseToWithdrawAmount,
+} from "./utils/helper";
 import { logger } from "@/utils";
 import { AUDIT_URL } from "../universal-lst-muliplier-strategy";
 import { getNoRiskTags } from "@/interfaces";
@@ -410,7 +415,7 @@ export class VesuExtendedMultiplierStrategy<
       logger.info(
         `${VesuExtendedMultiplierStrategy.name}::shouldInvest amountToInvest: ${amountToInvestNumber}`
       );
-      
+
       if (amountToInvest.lessThan(LIMIT_BALANCE_VALUE)) {
         return {
           shouldInvest: false,
@@ -498,7 +503,8 @@ export class VesuExtendedMultiplierStrategy<
           debtAmountToBeRepaid: new Web3Number(0, 0),
         };
       }
-      const amountToInvestAfterRepayingDebt = amountToInvest.minus(debtAmountToBeRepaid);
+      const amountToInvestAfterRepayingDebt =
+        amountToInvest.minus(debtAmountToBeRepaid);
       const { vesu_amount, extended_amount, extended_leverage, vesu_leverage } =
         await calculateAmountDistribution(
           amountToInvestAfterRepayingDebt.toNumber(),
@@ -1142,6 +1148,19 @@ export class VesuExtendedMultiplierStrategy<
             VesuExtendedMultiplierStrategy.name
           }::moveAssets extendedHoldingAmount: ${extendedHoldingAmount.toNumber()}`
         );
+        const extendedPositions = await extendedAdapter.getAllOpenPositions();
+        if (!extendedPositions) {
+          logger.error(
+            `error getting extended positions: ${extendedPositions} while moving assets from extended to vault`
+          );
+          return this.createTransactionResult(
+            [],
+            false,
+            params,
+            "NONE",
+            params.cycleType
+          );
+        }
         if (params.amount.abs().greaterThan(extendedHoldingAmount)) {
           const leftAmountAfterWithdrawalAmountInAccount = new Web3Number(
             Math.ceil(
@@ -1149,6 +1168,15 @@ export class VesuExtendedMultiplierStrategy<
             ),
             USDC_TOKEN_DECIMALS
           );
+          const positionAmountToClose =
+            await calculatePositionToCloseToWithdrawAmount(
+              extendedHoldings,
+              extendedPositions[0],
+              params.amount
+            );
+          logger.info(
+            `positionAmountToClose: ${positionAmountToClose} this is without leverage`
+          );
           logger.info(
             `${
               VesuExtendedMultiplierStrategy.name
@@ -1164,8 +1192,7 @@ export class VesuExtendedMultiplierStrategy<
             logger.error(`error fetching order book btc usdc: ${status}`);
             priceOfBTC = collateralPrice.price;
           }
-          const btcAmount =
-            leftAmountAfterWithdrawalAmountInAccount.dividedBy(priceOfBTC);
+          const btcAmount = positionAmountToClose.dividedBy(priceOfBTC);
           /**
            * If amount for withdrawal is greater than the amount in extended available for withdrawal,
            * then we need to open a long position depending on the difference between the two