@strkfarm/sdk 2.0.0-dev.1 → 2.0.0-dev.2

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

@@ -13,7 +13,7 @@ import { logger } from "@/utils";
 import { AUDIT_URL } from "../universal-lst-muliplier-strategy";
 import { getNoRiskTags } from "@/interfaces";
 import { _riskFactor } from "../universal-lst-muliplier-strategy";
-import { EXTENDED_QTY_PRECISION, LIMIT_BALANCE, MAX_PRICE_DIFFERENCE_BETWEEN_AVNU_AND_EXTENDED, MIN_PRICE_DIFFERENCE_BETWEEN_AVNU_AND_EXTENDED, MINIMUM_EXTENDED_POSITION_SIZE, USDC_TOKEN_DECIMALS, WBTC_TOKEN_DECIMALS } from "./utils/constants";
+import { BUFFER_USDC_IN_WITHDRAWAL, EXTENDED_QTY_PRECISION, LIMIT_BALANCE, MAX_PRICE_DIFFERENCE_BETWEEN_AVNU_AND_EXTENDED, MIN_PRICE_DIFFERENCE_BETWEEN_AVNU_AND_EXTENDED, MINIMUM_EXTENDED_POSITION_SIZE, USDC_TOKEN_DECIMALS, WALLET_ADDRESS, WBTC_TOKEN_DECIMALS } from "./utils/constants";
 import { PricerBase } from "@/modules/pricerBase";
 import { ContractAddr, Web3Number } from "@/dataTypes";
 import { Global } from "@/global";
@@ -108,6 +108,26 @@ export class VesuExtendedMultiplierStrategy<
       debtPrice,
     };
   }
+ 
+  async getUnusedBalanceUSDCE(): Promise<SingleTokenInfo> {
+    const usdceToken = Global.getDefaultTokens().find(
+      (token) => token.symbol === "USDCe"
+    )!;
+    const balance = await new ERC20(this.config).balanceOf(
+      usdceToken.address,
+      WALLET_ADDRESS,
+      usdceToken.decimals
+    );
+    const price = await this.pricer.getPrice(usdceToken.symbol);
+    const usdValue =
+      Number(balance.toFixed(usdceToken.decimals)) * price.price;
+    return {
+      tokenInfo: usdceToken,
+      amount: balance,
+      usdValue,
+    };
+  }
+
 
   async getUnusedBalanceWBTC(): Promise<SingleTokenInfo> {
     const collateralToken = this.metadata.additionalInfo.borrowable_assets[0]!;
@@ -159,23 +179,31 @@ export class VesuExtendedMultiplierStrategy<
     return extendedAdapter.adapter as ExtendedAdapter;
   }
 
-  async moveAssetsToVaultAllocator(amount: Web3Number): Promise<Call[]> {
-    try{
-      const usdcToken = Global.getDefaultTokens().find(
-        (token) => token.symbol === "USDC"
+  async moveAssetsToVaultAllocator(amount: Web3Number, extendedAdapter: ExtendedAdapter): Promise<Call[]> {
+    try {
+      const usdceToken = Global.getDefaultTokens().find(
+        (token) => token.symbol === "USDCe"
       )!;
       const approveCall = new ERC20(this.config).approve(
-        usdcToken.address,
+        usdceToken.address,
         this.metadata.additionalInfo.vaultAllocator,
         amount
       );
       const transferCall = new ERC20(this.config).transfer(
-        usdcToken.address,
+        usdceToken.address,
         this.metadata.additionalInfo.vaultAllocator,
         amount
       );
-      return [approveCall, transferCall];
-    }catch(err){
+      const proofsInfo = extendedAdapter.getProofsForFromLegacySwap(
+        this.getMerkleTree()
+      );
+      const proofGroups = proofsInfo.proofs;
+      const call = this.getManageCall(
+        proofGroups,
+        await proofsInfo.callConstructor({ amount: amount })
+      );
+      return [approveCall, transferCall, call];
+    } catch (err) {
       logger.error(`error moving assets to vault allocator: ${err}`);
       return [];
     }
@@ -307,11 +335,9 @@ export class VesuExtendedMultiplierStrategy<
         );
         return calls;
       }
-      console.log("extendedAmount", extendedAmount);
-      console.log("vesuAmount", vesuAmount);
       if (extendedAmount.lessThan(0)) {
         try {
-          const extendedCalls = await this.moveAssets(
+          const {calls: extendedCalls, status: extendedStatus} = await this.moveAssets(
             {
               to: Protocols.VAULT.name,
               from: Protocols.EXTENDED.name,
@@ -320,7 +346,12 @@ export class VesuExtendedMultiplierStrategy<
             extendedAdapter,
             vesuAdapter
           );
+          //If withdrawal succesfull, then do further
+          if(extendedStatus){
           calls.push(...extendedCalls);
+          }else{
+            return [];
+          }
         } catch (err) {
           logger.error(`Failed moving assets to vault: ${err}`);
         }
@@ -328,7 +359,7 @@ export class VesuExtendedMultiplierStrategy<
 
       if (vesuAmount.lessThan(0)) {
         try {
-          const vesuCalls = await this.moveAssets(
+          const {calls: vesuCalls, status: vesuStatus} = await this.moveAssets(
             {
               to: Protocols.EXTENDED.name,
               from: Protocols.VESU.name,
@@ -338,6 +369,9 @@ export class VesuExtendedMultiplierStrategy<
             vesuAdapter
           );
           calls.push(...vesuCalls);
+          if(!vesuStatus){
+            return [];
+          }
         } catch (err) {
           logger.error(`Failed moving assets to vault: ${err}`);
         }
@@ -355,7 +389,7 @@ export class VesuExtendedMultiplierStrategy<
       if (extendedAmount.minus(usdcAmountOnExtended).greaterThan(0)) {
         //move assets to extended
         try {
-          const extendedCalls = await this.moveAssets(
+          const {calls: extendedCalls} = await this.moveAssets(
             {
               to: Protocols.EXTENDED.name,
               from: Protocols.VAULT.name,
@@ -372,15 +406,18 @@ export class VesuExtendedMultiplierStrategy<
       if (vesuAmount.minus(usdcAmountInWallet).greaterThan(0)) {
         //move assets to vesu
         try {
-          const vesuCalls = await this.moveAssets(
+          const {calls: vesuCalls, status: vesuStatus} = await this.moveAssets(
             {
-              to: Protocols.VESU.name,
+              to: Protocols.VAULT.name,
               from: Protocols.EXTENDED.name,
               amount: vesuAmount.minus(usdcAmountInWallet),
             },
             extendedAdapter,
             vesuAdapter
           );
+          if(!vesuStatus){
+            return [];
+          }
           calls.push(...vesuCalls);
         } catch (err) {
           logger.error(`Failed moving assets to vault: ${err}`);
@@ -401,18 +438,25 @@ export class VesuExtendedMultiplierStrategy<
     },
     extendedAdapter: ExtendedAdapter,
     vesuAdapter: VesuMultiplyAdapter
-  ): Promise<Call[]> {
+  ): Promise<{
+    calls: Call[];
+    status: boolean;
+  }> {
     try {
       const avnuAdapter = await this.getAvnuAdapter();
       if (!avnuAdapter) {
         logger.error(`avnu adapter not found: ${avnuAdapter}`);
-        return [];
+        return {
+          calls: [],
+          status: false
+        };
       }
-      logger.info("moveAssets params", params);
+      logger.info(`moveAssets params, ${JSON.stringify(params)}`);
       const collateralToken = vesuAdapter.config.supportedPositions[0].asset;
       const {
         collateralPrice,
       } = await this.getAssetPrices();
+
       if (params.to === Protocols.EXTENDED.name && params.from === Protocols.VAULT.name) {
         const proofsInfo = extendedAdapter.getProofs(
           true,
@@ -425,22 +469,63 @@ export class VesuExtendedMultiplierStrategy<
           await proofsInfo.callConstructor({ amount: params.amount })
         );
         calls.push(call);
-        return calls;
+        return {
+          calls: [call],
+          status: true
+        };
       } else if (params.to === Protocols.VAULT.name && params.from === Protocols.EXTENDED.name) {
+        const extendedLeverage = calculateExtendedLevergae();
+        const extendedHoldings = await extendedAdapter.getExtendedDepositAmount();
+        if (!extendedHoldings) {
+          logger.error(`error getting extended holdings: ${extendedHoldings}`);
+          return {
+            calls: [],
+            status: false
+          };
+        }
+        const extendedHoldingAmount = new Web3Number(
+          extendedHoldings.availableForWithdrawal,
+          USDC_TOKEN_DECIMALS
+        );
+      
+        const leftAmountAfterWithdrawalAmountInAccount = params.amount.minus(extendedHoldingAmount);
+        const btcAmount = leftAmountAfterWithdrawalAmountInAccount.dividedBy(collateralPrice.price);
+        const openLongPosition = await extendedAdapter.createOrder(
+          extendedLeverage.toString(),
+          btcAmount.toNumber(),
+          OrderSide.BUY
+        )
+        if (!openLongPosition) {
+          logger.error(`error opening long position: ${openLongPosition}`);
+          return {
+            calls: [],
+            status: false
+          };
+        }
+        await new Promise(resolve => setTimeout(resolve, 5000));
         const withdrawalFromExtended =
           await extendedAdapter.withdrawFromExtended(params.amount);
         if (withdrawalFromExtended) {
-           /**
-           * We need to move assets from my wallet back to vault contract
-           */
-          const calls = await this.moveAssetsToVaultAllocator(params.amount);
+          /**
+          * We need to move assets from my wallet back to vault contract
+          */
+          const extendedHoldings = await extendedAdapter.getExtendedDepositAmount();
+          logger.info(`extendedHoldings after withdrawal ${extendedHoldings}`);
+          await new Promise(resolve => setTimeout(resolve, 10000));
+          const calls = await this.moveAssetsToVaultAllocator(params.amount, extendedAdapter);
           if (calls.length > 0) {
-            return calls;
+            return {
+              calls: calls,
+              status: true
+            };
           }
         } else {
           logger.error("withdrawal from extended failed");
+          return {
+            calls: [],
+            status: false
+          };
         }
-        return [];
       } else if (params.to === Protocols.VAULT.name && params.from === Protocols.VESU.name) {
         //withdraw from vesu 
         const vesuAmountInBTC = new Web3Number(
@@ -462,7 +547,10 @@ export class VesuExtendedMultiplierStrategy<
           await swapProofsInfo.callConstructor({ amount: vesuAmountInBTC })
         );
         calls.push(swapCall);
-        return calls;
+        return {
+          calls: calls,
+          status: true
+        };
       } else if (params.to === Protocols.EXTENDED.name && params.from === Protocols.VESU.name) {
         const vesuAmountInBTC = new Web3Number(
           params.amount.dividedBy(collateralPrice.price).toNumber(),
@@ -494,19 +582,28 @@ export class VesuExtendedMultiplierStrategy<
           await proofsInfoDeposit.callConstructor({ amount: params.amount })
         );
         calls.push(callDeposit);
-        return calls;
+        return {
+          calls: calls,
+          status: true
+        };
       }
-      console.warn("moveAssets received unsupported route:", params);
-      return [];
+      return {
+        calls: [],
+        status: false
+      };
     } catch (err) {
       logger.error(`error moving assets: ${err}`);
-      return [];
+      return {
+        calls: [],
+        status: false
+      };
     }
   }
 
   async handleDeposit(): Promise<{
-    extendedAmountInBTC : Web3Number,
-    calls:Call[]}> {
+    extendedAmountInBTC: Web3Number,
+    calls: Call[]
+  }> {
     try {
       const vesuAdapter = await this.getVesuAdapter();
       const extendedAdapter = await this.getExtendedAdapter();
@@ -567,10 +664,10 @@ export class VesuExtendedMultiplierStrategy<
         collateralTokenAmount,
         collateralPrice.price
       );
-      console.log("vesuAmountInBTC", vesuAmountInBTC);
-      console.log("extendedAmountInBTC", extendedAmountInBTC);
+     logger.info(`vesuAmountInBTC ${vesuAmountInBTC}, extendedAmountInBTC ${extendedAmountInBTC}`);
+     
       let calls: Call[] = [];
-      if(vesuAmountInBTC.greaterThan(MINIMUM_EXTENDED_POSITION_SIZE)){
+      if (vesuAmountInBTC.greaterThan(MINIMUM_EXTENDED_POSITION_SIZE)) {
         const proofsInfo = vesuAdapter.getProofs(true, this.getMerkleTree());
         const proofGroups = proofsInfo.proofs;
         const call = this.getManageCall(
@@ -581,7 +678,7 @@ export class VesuExtendedMultiplierStrategy<
         );
         const { amount: wbtcAmountInVaultAllocator } = await this.getUnusedBalanceWBTC();
         if (wbtcAmountInVaultAllocator.lessThan(vesuAmountInBTC)) {
-          console.log("error wbtc amount in vault allocator is less than vesu amount in btc", wbtcAmountInVaultAllocator, vesuAmountInBTC);
+          logger.info(`WBTC amount in vault allocator is less than vesu amount required in WBTC thus swapping, wbtcAmountInVaultAllocator: ${wbtcAmountInVaultAllocator}, vesuAmountInBTC: ${vesuAmountInBTC}`);
           const swapProofsInfo = avnuAdapter.getProofs(true, this.getMerkleTree());
           const swapProofGroups = swapProofsInfo.proofs;
           const swapCall = this.getManageCall(
@@ -620,44 +717,54 @@ export class VesuExtendedMultiplierStrategy<
     }
   }
 
-  async checkPriceDifferenceBetweenAvnuAndExtended(extendedAdapter:ExtendedAdapter, vesuAdapter:VesuMultiplyAdapter, avnuAdapter:AvnuAdapter): Promise<boolean> {
+  async checkPriceDifferenceBetweenAvnuAndExtended(extendedAdapter: ExtendedAdapter, vesuAdapter: VesuMultiplyAdapter, avnuAdapter: AvnuAdapter): Promise<boolean> {
     const {
       ask, bid
-    }= await extendedAdapter.fetchOrderBookBTCUSDC();
+    } = await extendedAdapter.fetchOrderBookBTCUSDC();
     const price = ask.plus(bid).dividedBy(2);
-    const btcToken = vesuAdapter.config.supportedPositions[1].asset;
+    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;
     }
     const priceDifference = price.minus(btcPriceAvnu).toNumber();
-    if(priceDifference < MAX_PRICE_DIFFERENCE_BETWEEN_AVNU_AND_EXTENDED && priceDifference > MIN_PRICE_DIFFERENCE_BETWEEN_AVNU_AND_EXTENDED){
+    if (priceDifference < MAX_PRICE_DIFFERENCE_BETWEEN_AVNU_AND_EXTENDED && priceDifference > MIN_PRICE_DIFFERENCE_BETWEEN_AVNU_AND_EXTENDED) {
       return true;
     }
     logger.error(`price difference between avnu and extended doesn't fit the range, priceDifference: ${priceDifference}`);
     return false;
   }
 
-  async handleWithdraw(amount: Web3Number): Promise<Call[]> {
+  async handleWithdraw(amount: Web3Number): Promise<{calls: Call[], status: boolean}> {
     try {
       const usdcBalanceVaultAllocator = await this.getUnusedBalance()
-      const usdcBalanceDifference = amount.minus(usdcBalanceVaultAllocator.usdValue);
+      const usdcBalanceDifference = amount.plus(BUFFER_USDC_IN_WITHDRAWAL).minus(usdcBalanceVaultAllocator.usdValue);
       logger.info(`usdcBalanceDifference, ${usdcBalanceDifference.toNumber()}`);
+      let calls: Call[] = [];
+      let status: boolean = true;
       if (usdcBalanceDifference.lessThan(0)) {
         const withdrawCall = await this.getBringLiquidityCall({
-          amount: amount
+          amount: usdcBalanceVaultAllocator.amount
         })
         logger.info("withdraw call", withdrawCall);
-        return [withdrawCall];
+        calls.push(withdrawCall);
+        return {
+          calls:calls,
+          status:true
+        };
       }
       const vesuAdapter = await this.getVesuAdapter();
       const extendedAdapter = await this.getExtendedAdapter();
       if (!vesuAdapter || !extendedAdapter || !extendedAdapter.client) {
+        status = false;
         logger.error(
           `vesu or extended adapter not found: vesuAdapter=${vesuAdapter}, extendedAdapter=${extendedAdapter}`
         );
-        return [];
+        return {
+          calls:calls,
+          status:status
+        };
       }
       const { collateralTokenAmount } =
         await vesuAdapter.vesuAdapter.getAssetPrices();
@@ -665,22 +772,35 @@ export class VesuExtendedMultiplierStrategy<
         collateralPrice
       } = await this.getAssetPrices();
       const extendedPositon = await extendedAdapter.getAllOpenPositions();
+      if(!extendedPositon) {
+        status = false;
+        logger.error("error getting extended position", extendedPositon);
+        return {
+          calls:calls,
+          status:status
+        }
+      }
       const amountDistributionForWithdrawal =
         await calculateAmountDistributionForWithdrawal(
-          amount,
+          usdcBalanceDifference,
           collateralPrice.price,
           collateralTokenAmount,
           extendedPositon
         );
       if (!amountDistributionForWithdrawal) {
+        status = false;
         logger.error(
           `error calculating amount distribution for withdrawal: ${amountDistributionForWithdrawal}`
         );
-        return [];
+        return {
+          calls:calls,
+          status:status
+        };
       }
       const { vesu_amount, extended_amount } = amountDistributionForWithdrawal;
-      if (vesu_amount.greaterThan(0)) {
-        const result = await this.moveAssets(
+    
+      if (status && vesu_amount.greaterThan(0)) {
+        const {calls: vesuCalls, status: vesuStatus} = await this.moveAssets(
           {
             amount: vesu_amount,
             from: Protocols.VESU.name,
@@ -689,10 +809,11 @@ export class VesuExtendedMultiplierStrategy<
           extendedAdapter,
           vesuAdapter
         );
-        return result;
+        status = vesuStatus;
+        calls.push(...vesuCalls);
       }
-      if (extended_amount.greaterThan(0)) {
-        const result = await this.moveAssets(
+      if (status && extended_amount.greaterThan(0)) {
+        const {calls: extendedCalls, status: extendedStatus} = await this.moveAssets(
           {
             amount: extended_amount,
             from: Protocols.EXTENDED.name,
@@ -701,12 +822,32 @@ export class VesuExtendedMultiplierStrategy<
           extendedAdapter,
           vesuAdapter
         );
-        return result;
+        status = extendedStatus;
+        if(status) {
+          calls.push(...extendedCalls);
+        }else{
+          logger.error("error moving assets to vault: extendedStatus: ${extendedStatus}");
+          return {
+            calls: [],
+            status: status
+          };
+        }
       }
-      return [];
+      const withdrawCall = await this.getBringLiquidityCall({
+        amount: amount
+      })
+      logger.info("withdraw call", withdrawCall);
+      calls.push(withdrawCall);
+      return {
+        calls: calls,
+        status: status
+      };
     } catch (err) {
       logger.error(`error handling withdrawal: ${err}`);
-      return [];
+      return {
+        calls: [],
+        status: false
+      };
     }
   }
 
@@ -714,7 +855,7 @@ export class VesuExtendedMultiplierStrategy<
     const allPositions: PositionInfo[] = [];
     for (let adapter of this.metadata.additionalInfo.adapters) {
       const positions = await adapter.adapter.getPositions();
-     allPositions.push(...positions);
+      allPositions.push(...positions);
     }
 
     const assetPrice = await this.pricer.getPrice(this.asset().symbol);
@@ -863,6 +1004,7 @@ function getLooperSettings(
     vesuMultiplyAdapter.getWithdrawLeaf()
   );
   vaultSettings.leafAdapters.push(() => extendedAdapter.getDepositLeaf());
+  vaultSettings.leafAdapters.push(() => extendedAdapter.getSwapFromLegacyLeaf());
   vaultSettings.leafAdapters.push(() => avnuAdapter.getDepositLeaf());
   vaultSettings.leafAdapters.push(() => avnuAdapter.getWithdrawLeaf());
   // Doubt here, should this be usdcToken.address, or wbtcToken.address?