@strkfarm/sdk 2.0.0-dev.7 → 2.0.0-dev.8

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

@@ -218,11 +218,42 @@ export class VesuExtendedMultiplierStrategy<
     vesuLeverage: number;
   }> {
     try {
+      logger.info(`${VesuExtendedMultiplierStrategy.name}::shouldInvest starting`);
       const vesuAdapter = await this.getVesuAdapter();
       const extendedAdapter = await this.getExtendedAdapter();
-      if (!vesuAdapter || !extendedAdapter || !extendedAdapter.client) {
+      logger.info(`${VesuExtendedMultiplierStrategy.name}::shouldInvest adapters fetched: vesuAdapter=${!!vesuAdapter}, extendedAdapter=${!!extendedAdapter}, extendedAdapter.client=${!!extendedAdapter?.client}`);
+      
+      if (!vesuAdapter) {
         logger.error(
-          `vesu or extended adapter not found: vesuAdapter=${vesuAdapter}, extendedAdapter=${extendedAdapter}`
+          `Vesu adapter not configured in metadata. This is a configuration issue, not a temporary failure.`
+        );
+        return {
+          shouldInvest: false,
+          vesuAmount: new Web3Number(0, 0),
+          extendedAmount: new Web3Number(0, 0),
+          extendedLeverage: 0,
+          collateralPrice: 0,
+          debtPrice: 0,
+          vesuLeverage: 0,
+        };
+      }
+      if (!extendedAdapter) {
+        logger.error(
+          `Extended adapter not configured in metadata. This is a configuration issue, not a temporary failure.`
+        );
+        return {
+          shouldInvest: false,
+          vesuAmount: new Web3Number(0, 0),
+          extendedAmount: new Web3Number(0, 0),
+          extendedLeverage: 0,
+          collateralPrice: 0,
+          debtPrice: 0,
+          vesuLeverage: 0,
+        };
+      }
+      if (!extendedAdapter.client) {
+        logger.error(
+          `Extended adapter client not initialized. This may be a temporary initialization failure - check network connectivity and API availability.`
         );
         return {
           shouldInvest: false,
@@ -234,11 +265,65 @@ export class VesuExtendedMultiplierStrategy<
           vesuLeverage: 0,
         };
       }
+      
+      logger.info(`${VesuExtendedMultiplierStrategy.name}::shouldInvest calling getUnusedBalance`);
       const balance = await this.getUnusedBalance();
+      
+      if (!Number.isFinite(balance.usdValue) || balance.usdValue < 0) {
+        logger.error(
+          `Invalid balance.usdValue: ${balance.usdValue}. Expected a finite, non-negative number.`
+        );
+        return {
+          shouldInvest: false,
+          vesuAmount: new Web3Number(0, 0),
+          extendedAmount: new Web3Number(0, 0),
+          extendedLeverage: 0,
+          collateralPrice: 0,
+          debtPrice: 0,
+          vesuLeverage: 0,
+        };
+      }
+      logger.info(`${VesuExtendedMultiplierStrategy.name}::shouldInvest balance: ${balance.usdValue}`);
       const usdcBalanceOnExtended = await extendedAdapter.getExtendedDepositAmount();
+      
+      if (usdcBalanceOnExtended) {
+        const availableForWithdrawal = parseFloat(usdcBalanceOnExtended.availableForWithdrawal);
+        if (!Number.isFinite(availableForWithdrawal) || availableForWithdrawal < 0) {
+          logger.error(
+            `Invalid usdcBalanceOnExtended.availableForWithdrawal: ${usdcBalanceOnExtended.availableForWithdrawal}. Expected a finite, non-negative number.`
+          );
+          return {
+            shouldInvest: false,
+            vesuAmount: new Web3Number(0, 0),
+            extendedAmount: new Web3Number(0, 0),
+            extendedLeverage: 0,
+            collateralPrice: 0,
+            debtPrice: 0,
+            vesuLeverage: 0,
+          };
+        }
+      }
+      
       /** The LIMIT_BALANCE is the bffer amount to keep in the investing Cycle */
       const amountToInvest = new Web3Number(balance.usdValue, USDC_TOKEN_DECIMALS).plus(usdcBalanceOnExtended?.availableForWithdrawal ?? 0).multipliedBy(1 - LIMIT_BALANCE);
-      logger.info(`${VesuExtendedMultiplierStrategy.name}::shouldInvest amountToInvest: ${amountToInvest.toNumber()}`);
+      
+      const amountToInvestNumber = amountToInvest.toNumber();
+      if (!Number.isFinite(amountToInvestNumber)) {
+        logger.error(
+          `Invalid amountToInvest calculation result: ${amountToInvestNumber}. Calculation may have produced NaN or Infinity.`
+        );
+        return {
+          shouldInvest: false,
+          vesuAmount: new Web3Number(0, 0),
+          extendedAmount: new Web3Number(0, 0),
+          extendedLeverage: 0,
+          collateralPrice: 0,
+          debtPrice: 0,
+          vesuLeverage: 0,
+        };
+      }
+      
+      logger.info(`${VesuExtendedMultiplierStrategy.name}::shouldInvest amountToInvest: ${amountToInvestNumber}`);
       if (amountToInvest.lessThan(0)) {
         return {
           shouldInvest: false,
@@ -271,6 +356,37 @@ export class VesuExtendedMultiplierStrategy<
         collateralPrice,
         debtPrice
       } = await this.getAssetPrices();
+      
+
+      if (!Number.isFinite(collateralPrice.price) || collateralPrice.price <= 0) {
+        logger.error(
+          `Invalid collateralPrice: ${collateralPrice.price}. Expected a finite, positive number.`
+        );
+        return {
+          shouldInvest: false,
+          vesuAmount: new Web3Number(0, 0),
+          extendedAmount: new Web3Number(0, 0),
+          extendedLeverage: 0,
+          collateralPrice: 0,
+          debtPrice: 0,
+          vesuLeverage: 0,
+        };
+      }
+      if (!Number.isFinite(debtPrice.price) || debtPrice.price <= 0) {
+        logger.error(
+          `Invalid debtPrice: ${debtPrice.price}. Expected a finite, positive number.`
+        );
+        return {
+          shouldInvest: false,
+          vesuAmount: new Web3Number(0, 0),
+          extendedAmount: new Web3Number(0, 0),
+          extendedLeverage: 0,
+          collateralPrice: 0,
+          debtPrice: 0,
+          vesuLeverage: 0,
+        };
+      }
+      
       const { vesu_amount, extended_amount, extended_leverage, vesu_leverage } =
         await calculateAmountDistribution(
           amountToInvest.toNumber(),
@@ -328,13 +444,64 @@ export class VesuExtendedMultiplierStrategy<
     try {
       const vesuAdapter = await this.getVesuAdapter();
       const extendedAdapter = await this.getExtendedAdapter();
-      let calls: Call[] = [];
       if (!vesuAdapter || !extendedAdapter || !extendedAdapter.client) {
         logger.error(
           `vesu or extended adapter not found: vesuAdapter=${vesuAdapter}, extendedAdapter=${extendedAdapter}`
         );
-        return calls;
+        return [];
+      }
+
+      const extendedHoldings = await extendedAdapter.getExtendedDepositAmount();
+      if (!extendedHoldings) {
+        logger.error(`error getting extended holdings: ${extendedHoldings}`);
+        return [];
+      }
+      const usdcAmountInWallet = (await this.getUnusedBalance()).amount;
+      const usdcAmountOnExtendedAvailableForWithdrawal = parseFloat(
+        extendedHoldings.availableForWithdrawal
+      );
+
+      logger.info(`${VesuExtendedMultiplierStrategy.name}::shouldMoveAssets calculating movements - Extended current: ${usdcAmountOnExtendedAvailableForWithdrawal}, Wallet: ${usdcAmountInWallet.toNumber()}, Target Extended: ${extendedAmount.toNumber()}, Target Vesu: ${vesuAmount.toNumber()}`);
+
+      let totalExtendedWithdrawal = new Web3Number(0, USDC_TOKEN_DECIMALS);
+      let totalExtendedDeposit = new Web3Number(0, USDC_TOKEN_DECIMALS);
+
+      if (extendedAmount.isNegative() && extendedAmount.abs().greaterThan(extendedAdapter.minimumExtendedMovementAmount)) {
+        totalExtendedWithdrawal = totalExtendedWithdrawal.plus(extendedAmount.abs());
       }
+      
+      // Calculate remaining Extended difference (target vs current)
+      // If extendedAmount was negative, we've already accounted for that withdrawal
+      // So we calculate based on what Extended will be after that withdrawal
+      const extendedTargetAmount = extendedAmount.abs(); // Use absolute value as target
+      let projectedExtendedBalance = usdcAmountOnExtendedAvailableForWithdrawal;
+      
+      if (extendedAmount.isNegative()) {
+        projectedExtendedBalance = projectedExtendedBalance - extendedAmount.abs().toNumber();
+      }
+      
+      const extendedAmountDifference = extendedTargetAmount.minus(projectedExtendedBalance);
+      const extendedAmountDifferenceAbs = extendedAmountDifference.abs();
+      
+      // Track additional Extended movements
+      if (extendedAmountDifference.lessThan(0)) {
+        totalExtendedWithdrawal = totalExtendedWithdrawal.plus(extendedAmountDifferenceAbs);
+      } else if (extendedAmountDifference.greaterThan(0)) {
+        totalExtendedDeposit = totalExtendedDeposit.plus(extendedAmountDifference);
+      }
+    
+      const vesuTargetAmount = vesuAmount.abs();
+      const projectedWalletBalance = usdcAmountInWallet
+        .plus(totalExtendedWithdrawal)
+        .minus(totalExtendedDeposit);
+      
+      let vesuAmountDifference = vesuTargetAmount.minus(projectedWalletBalance);
+      const vesuAmountDifferenceAbs = vesuAmountDifference.abs();
+      
+      logger.info(`${VesuExtendedMultiplierStrategy.name}::shouldMoveAssets calculated movements - Extended withdrawal: ${totalExtendedWithdrawal.toNumber()}, Extended deposit: ${totalExtendedDeposit.toNumber()}, Extended diff: ${extendedAmountDifference.toNumber()}, Projected wallet: ${projectedWalletBalance.toNumber()}, Vesu diff: ${vesuAmountDifference.toNumber()}`);
+      let calls: Call[] = [];
+
+      // Handle negative extendedAmount (initial withdrawal needed)
       if (extendedAmount.isNegative() && extendedAmount.abs().greaterThan(extendedAdapter.minimumExtendedMovementAmount)) {
         try {
           const { calls: extendedCalls, status: extendedStatus } = await this.moveAssets(
@@ -346,7 +513,6 @@ export class VesuExtendedMultiplierStrategy<
             extendedAdapter,
             vesuAdapter
           );
-          //If withdrawal succesfull, then do further
           if (extendedStatus) {
             calls.push(...extendedCalls);
           } else {
@@ -357,7 +523,7 @@ export class VesuExtendedMultiplierStrategy<
         }
       }
 
-      if (vesuAmount.isNegative() && vesuAmount.lessThan(vesuAdapter.minimumVesuMovementAmount)) {
+      if (vesuAmount.isNegative() && vesuAmount.abs().greaterThan(vesuAdapter.minimumVesuMovementAmount)) {
         try {
           const { calls: vesuCalls, status: vesuStatus } = await this.moveAssets(
             {
@@ -377,52 +543,83 @@ export class VesuExtendedMultiplierStrategy<
         }
       }
 
-      const extendedHoldings = await extendedAdapter.getExtendedDepositAmount();
-      if (!extendedHoldings) {
-        logger.error(`error getting extended holdings: ${extendedHoldings}`);
-        return calls;
-      }
-      const usdcAmountInWallet = (await this.getUnusedBalance()).amount;
-      const usdcAmountOnExtended = parseFloat(
-        extendedHoldings.availableForWithdrawal
-      );
-      if (extendedAmount.minus(usdcAmountOnExtended).greaterThan(extendedAdapter.minimumExtendedMovementAmount)) {
-        //move assets to extended
-        try {
-          const { calls: extendedCalls } = await this.moveAssets(
-            {
-              to: Protocols.EXTENDED.name,
-              from: Protocols.VAULT.name,
-              amount: extendedAmount.minus(usdcAmountOnExtended),
-            },
-            extendedAdapter,
-            vesuAdapter
-          );
-          calls.push(...extendedCalls);
-        } catch (err) {
-          logger.error(`Failed moving assets to extended: ${err}`);
+      // Handle Extended adjustments based on calculated difference
+      if (extendedAmountDifferenceAbs.greaterThan(extendedAdapter.minimumExtendedMovementAmount)) {
+        if (extendedAmountDifference.greaterThan(0)) {
+          try {
+            const { calls: extendedCalls, status: extendedStatus } = await this.moveAssets(
+              {
+                to: Protocols.EXTENDED.name,
+                from: Protocols.VAULT.name,
+                amount: extendedAmountDifference,
+              },
+              extendedAdapter,
+              vesuAdapter
+            );
+            if (extendedStatus) {
+              calls.push(...extendedCalls);
+            } else {
+              logger.error(`Failed to move assets to extended - operation returned false status`);
+              return [];
+            }
+          } catch (err) {
+            logger.error(`Failed moving assets to extended: ${err}`);
+            return [];
+          }
+        } else if (extendedAmountDifference.lessThan(0)) {
+          try {
+            const { calls: extendedCalls, status: extendedStatus } = await this.moveAssets(
+              {
+                to: Protocols.VAULT.name,
+                from: Protocols.EXTENDED.name,
+                amount: extendedAmountDifferenceAbs,
+              },
+              extendedAdapter,
+              vesuAdapter
+            );
+            if (extendedStatus) {
+              calls.push(...extendedCalls);
+            } else {
+              logger.error(`Failed to withdraw from extended - operation returned false status`);
+              return [];
+            }
+          } catch (err) {
+            logger.error(`Failed moving assets from extended to vault: ${err}`);
+            return [];
+          }
         }
       }
-      if (vesuAmount.minus(usdcAmountInWallet).greaterThan(vesuAdapter.minimumVesuMovementAmount)) {
-        //move assets to vesu
-        try {
-          const { calls: vesuCalls, status: vesuStatus } = await this.moveAssets(
-            {
-              to: Protocols.VAULT.name,
-              from: Protocols.EXTENDED.name,
-              amount: vesuAmount.minus(usdcAmountInWallet),
-            },
-            extendedAdapter,
-            vesuAdapter
+      
+      // Handle Vesu adjustments based on calculated difference (already adjusted for Extended movements)
+      if (vesuAmountDifferenceAbs.greaterThan(vesuAdapter.minimumVesuMovementAmount)) {
+        if (vesuAmountDifference.lessThanOrEqualTo(0)) {
+          logger.warn(
+            `Vesu amount difference is negative or zero: ${vesuAmountDifference.toNumber()}. Skipping operation.`
           );
-          if (!vesuStatus) {
+        } else {
+          // Move assets from Extended to Vault (which will then go to Vesu)
+          try {
+            const { calls: vesuCalls, status: vesuStatus } = await this.moveAssets(
+              {
+                to: Protocols.VAULT.name,
+                from: Protocols.EXTENDED.name,
+                amount: vesuAmountDifference,
+              },
+              extendedAdapter,
+              vesuAdapter
+            );
+            if (!vesuStatus) {
+              logger.error(`Failed to move assets to vesu - operation returned false status`);
+              return [];
+            }
+            calls.push(...vesuCalls);
+          } catch (err) {
+            logger.error(`Failed moving assets to vault: ${err}`);
             return [];
           }
-          calls.push(...vesuCalls);
-        } catch (err) {
-          logger.error(`Failed moving assets to vault: ${err}`);
         }
       }
+      
       return calls;
     } catch (err) {
       logger.error(`Failed moving assets to vesu: ${err}`);
@@ -443,6 +640,42 @@ export class VesuExtendedMultiplierStrategy<
     status: boolean;
   }> {
     try {
+      // Validate amount is positive before starting operations
+      if (params.amount.lessThanOrEqualTo(0)) {
+        logger.error(
+          `Invalid amount for moveAssets: ${params.amount.toNumber()}. Amount must be positive.`
+        );
+        return {
+          calls: [],
+          status: false
+        };
+      }
+
+      // Check minimum movement amounts before starting operations
+      const amountAbs = params.amount.abs();
+      if (params.from === Protocols.EXTENDED.name || params.to === Protocols.EXTENDED.name) {
+        if (amountAbs.lessThanOrEqualTo(extendedAdapter.minimumExtendedMovementAmount)) {
+          logger.warn(
+            `Amount ${amountAbs.toNumber()} is below minimum Extended movement amount ${extendedAdapter.minimumExtendedMovementAmount}. Skipping operation.`
+          );
+          return {
+            calls: [],
+            status: false
+          };
+        }
+      }
+      if (params.from === Protocols.VESU.name || params.to === Protocols.VESU.name) {
+        if (amountAbs.lessThanOrEqualTo(vesuAdapter.minimumVesuMovementAmount)) {
+          logger.warn(
+            `Amount ${amountAbs.toNumber()} is below minimum Vesu movement amount ${vesuAdapter.minimumVesuMovementAmount}. Skipping operation.`
+          );
+          return {
+            calls: [],
+            status: false
+          };
+        }
+      }
+
       const avnuAdapter = await this.getAvnuAdapter();
       if (!avnuAdapter) {
         logger.error(`avnu adapter not found: ${avnuAdapter}`);
@@ -503,12 +736,13 @@ export class VesuExtendedMultiplierStrategy<
           )
           if (!openLongPosition) {
             logger.error(`error opening long position: ${openLongPosition}`);
-            return {
-              calls: [],
-              status: false
-            };
           }
           await new Promise(resolve => setTimeout(resolve, 5000));
+          const updatedHoldings = await extendedAdapter.getExtendedDepositAmount();
+          if (!updatedHoldings || new Web3Number(updatedHoldings.availableForWithdrawal, USDC_TOKEN_DECIMALS).lessThan(params.amount.abs())) {
+            logger.error(`Insufficient balance after opening position. Available: ${updatedHoldings?.availableForWithdrawal}, Needed: ${params.amount.abs()}`);
+            return { calls: [], status: false };
+          }
         }
         const withdrawalFromExtended =
           await extendedAdapter.withdrawFromExtended(params.amount);