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

package/dist/index.browser.mjs

@@ -29919,8 +29919,47 @@ var ExtendedAdapter = class _ExtendedAdapter extends BaseAdapter {
   async withdrawFromExtended(amount) {
     try {
       if (!this.client) {
-        throw new Error("Client not initialized");
+        logger.error("Client not initialized");
+        return false;
+      }
+      if (amount.lessThanOrEqualTo(0)) {
+        logger.error(
+          `Invalid withdrawal amount: ${amount.toNumber()}. Amount must be positive.`
+        );
+        return false;
+      }
+      if (amount.lessThanOrEqualTo(this.minimumExtendedMovementAmount)) {
+        logger.warn(
+          `Withdrawal amount ${amount.toNumber()} is below minimum Extended movement amount ${this.minimumExtendedMovementAmount}. Skipping withdrawal.`
+        );
+        return false;
+      }
+      const holdings = await this.getExtendedDepositAmount();
+      if (!holdings) {
+        logger.error(
+          "Cannot get holdings - unable to validate withdrawal amount"
+        );
+        return false;
       }
+      const availableForWithdrawal = parseFloat(
+        holdings.availableForWithdrawal
+      );
+      if (!Number.isFinite(availableForWithdrawal) || availableForWithdrawal < 0) {
+        logger.error(
+          `Invalid availableForWithdrawal: ${holdings.availableForWithdrawal}. Expected a finite, non-negative number.`
+        );
+        return false;
+      }
+      const withdrawalAmount = amount.toNumber();
+      if (withdrawalAmount > availableForWithdrawal) {
+        logger.error(
+          `Withdrawal amount ${withdrawalAmount} exceeds available balance ${availableForWithdrawal}`
+        );
+        return false;
+      }
+      logger.info(
+        `Withdrawing ${withdrawalAmount} from Extended. Available balance: ${availableForWithdrawal}`
+      );
       const withdrawalRequest = await this.client.withdrawUSDC(
         amount.toFixed(2)
       );
@@ -29931,6 +29970,9 @@ var ExtendedAdapter = class _ExtendedAdapter extends BaseAdapter {
         );
         return withdrawalStatus;
       }
+      logger.error(
+        `Withdrawal request failed with status: ${withdrawalRequest.status}`
+      );
       return false;
     } catch (error) {
       logger.error(`Error creating Withdraw Call: ${error}`);
@@ -29941,21 +29983,44 @@ var ExtendedAdapter = class _ExtendedAdapter extends BaseAdapter {
     return Promise.resolve(1);
   }
   async getExtendedDepositAmount() {
-    if (this.client === null) {
-      logger.error("error initializing client");
-      return void 0;
-    }
-    const result = await this.client.getHoldings();
-    if (!result) {
-      logger.error(`error getting holdings: ${result}`);
-      return void 0;
-    }
-    const holdings = result.data;
-    if (!holdings) {
-      logger.error(`error getting holdings: ${holdings}`);
+    try {
+      if (this.client === null) {
+        logger.error("error initializing client - client is null");
+        return void 0;
+      }
+      const result = await this.client.getHoldings();
+      if (!result) {
+        logger.error("error getting holdings - API returned null/undefined");
+        return void 0;
+      }
+      if (result.status && result.status !== "OK") {
+        logger.error(
+          `error getting holdings - API returned status: ${result.status}`
+        );
+        return void 0;
+      }
+      const holdings = result.data;
+      if (!holdings) {
+        logger.warn(
+          "holdings data is null/undefined - treating as zero balance"
+        );
+        return {
+          collateral_name: "",
+          balance: "0",
+          equity: "0",
+          availableForTrade: "0",
+          availableForWithdrawal: "0",
+          unrealisedPnl: "0",
+          initialMargin: "0",
+          marginRatio: "0",
+          updatedTime: Date.now()
+        };
+      }
+      return holdings;
+    } catch (error) {
+      logger.error(`error getting holdings - exception: ${error}`);
       return void 0;
     }
-    return holdings;
   }
   async setLeverage(leverage, marketName) {
     if (this.client === null) {
@@ -29997,38 +30062,24 @@ var ExtendedAdapter = class _ExtendedAdapter extends BaseAdapter {
     return result.data;
   }
   async getOrderStatus(orderId, marketName) {
-    if (this.client === null) {
-      logger.error("error initializing client");
-      return null;
-    }
-    let orderhistory = await this.getOrderHistory(marketName);
-    if (!orderhistory || orderhistory.length === 0) {
-      logger.error(`error getting order history: ${orderId}`);
-    } else {
-      const order = orderhistory.slice(0, 10).find((order2) => order2.id.toString() === orderId);
-      if (order) {
-        return order;
+    try {
+      if (this.client === null) {
+        logger.error("error initializing client");
+        return null;
       }
-    }
-    for (let attempt = 1; attempt <= 5; attempt++) {
-      await new Promise((resolve) => setTimeout(resolve, this.retryDelayForOrderStatus));
-      orderhistory = await this.getOrderHistory(marketName);
+      const orderhistory = await this.getOrderHistory(marketName);
       if (!orderhistory || orderhistory.length === 0) {
-        logger.error(
-          `error getting order history on retry ${attempt}: ${orderId}`
-        );
-        continue;
+        return null;
       }
-      const order = orderhistory.slice(0, 5).find((order2) => order2.id.toString() === orderId);
-      if (order && order.status === "FILLED" /* FILLED */) {
+      const order = orderhistory.slice(0, 20).find((order2) => order2.id.toString() === orderId);
+      if (order) {
         return order;
       }
-      logger.error(
-        `order not found in top 15 entries on retry ${attempt}: ${orderId}`
-      );
+      return null;
+    } catch (error) {
+      logger.error(`error getting order status: ${error}`);
+      return null;
     }
-    logger.error(`error getting order after all retries: ${orderId}`);
-    return null;
   }
   async fetchOrderBookBTCUSDC() {
     try {
@@ -30079,14 +30130,40 @@ var ExtendedAdapter = class _ExtendedAdapter extends BaseAdapter {
         logger.error("error depositing or setting leverage");
         return null;
       }
-      const positions = await this.getAllOpenPositions();
-      if (positions === null) {
+      const { ask, bid } = await this.fetchOrderBookBTCUSDC();
+      if (!ask || !bid || ask.lessThanOrEqualTo(0) || bid.lessThanOrEqualTo(0)) {
+        logger.error(
+          `Invalid orderbook prices: ask=${ask?.toNumber()}, bid=${bid?.toNumber()}`
+        );
         return null;
       }
-      const { ask, bid } = await this.fetchOrderBookBTCUSDC();
       const spread = ask.minus(bid);
-      let price = ask.plus(bid).div(2);
-      side === "SELL" /* SELL */ ? price = price.minus(spread.times(0.2 * attempt)) : price = price.plus(spread.times(0.2 * attempt));
+      const midPrice = ask.plus(bid).div(2);
+      const MAX_PRICE_DEVIATION_MULTIPLIER = 0.5;
+      const priceAdjustmentMultiplier = Math.min(
+        0.2 * attempt,
+        MAX_PRICE_DEVIATION_MULTIPLIER
+      );
+      const priceAdjustment = spread.times(priceAdjustmentMultiplier);
+      let price = midPrice;
+      if (side === "SELL" /* SELL */) {
+        price = midPrice.minus(priceAdjustment);
+      } else {
+        price = midPrice.plus(priceAdjustment);
+      }
+      const maxDeviation = midPrice.times(0.5);
+      if (price.minus(midPrice).abs().greaterThan(maxDeviation)) {
+        logger.error(
+          `Price deviation too large on attempt ${attempt}: price=${price.toNumber()}, midPrice=${midPrice.toNumber()}, deviation=${price.minus(midPrice).abs().toNumber()}`
+        );
+        if (attempt >= maxAttempts) {
+          return null;
+        }
+        price = side === "SELL" /* SELL */ ? midPrice.minus(maxDeviation) : midPrice.plus(maxDeviation);
+      }
+      logger.info(
+        `createOrder attempt ${attempt}/${maxAttempts}: side=${side}, midPrice=${midPrice.toNumber()}, adjustedPrice=${price.toNumber()}, adjustment=${priceAdjustmentMultiplier * 100}%`
+      );
       const amount_in_token = (btcAmount * parseInt(leverage)).toFixed(
         this.config.extendedPrecision
       );
@@ -30097,17 +30174,57 @@ var ExtendedAdapter = class _ExtendedAdapter extends BaseAdapter {
         price.toFixed(0),
         side
       );
-      if (!result) {
+      if (!result || !result.position_id) {
+        logger.error("Failed to create order - no position_id returned");
         return null;
       }
-      await new Promise((resolve) => setTimeout(resolve, 5e3));
-      const openOrder = await this.getOrderStatus(
-        result.position_id,
+      const positionId = result.position_id;
+      logger.info(
+        `Order created with position_id: ${positionId}. Waiting for API to update...`
+      );
+      let openOrder = await this.getOrderStatus(
+        positionId,
         this.config.extendedMarketName
       );
+      const maxStatusRetries = 3;
+      const statusRetryDelay = 5e3;
       if (!openOrder) {
+        logger.warn(
+          `Order ${positionId} not found in API yet. Retrying status fetch (max ${maxStatusRetries} times)...`
+        );
+        for (let statusRetry = 1; statusRetry <= maxStatusRetries; statusRetry++) {
+          await new Promise((resolve) => setTimeout(resolve, statusRetryDelay));
+          openOrder = await this.getOrderStatus(
+            positionId,
+            this.config.extendedMarketName
+          );
+          if (openOrder) {
+            logger.info(
+              `Order ${positionId} found after ${statusRetry} status retry(ies)`
+            );
+            break;
+          }
+          logger.warn(
+            `Order ${positionId} still not found after ${statusRetry}/${maxStatusRetries} status retries`
+          );
+        }
+      }
+      if (openOrder && openOrder.status === "FILLED" /* FILLED */) {
+        logger.info(
+          `Order ${positionId} successfully filled with quantity ${openOrder.qty}`
+        );
+        return {
+          position_id: positionId,
+          btc_exposure: openOrder.qty
+        };
+      } else if (openOrder && openOrder.status !== "FILLED" /* FILLED */) {
+        logger.warn(
+          `Order ${positionId} found but status is ${openOrder.status}, not FILLED. Retrying order creation...`
+        );
         if (attempt >= maxAttempts) {
-          logger.error("Max retries reached \u2014 could not verify open position");
+          logger.error(
+            `Max retries reached \u2014 order ${positionId} status is ${openOrder.status}, not FILLED`
+          );
           return null;
         } else {
           const backoff = 2e3 * attempt;
@@ -30121,9 +30238,12 @@ var ExtendedAdapter = class _ExtendedAdapter extends BaseAdapter {
           );
         }
       } else {
+        logger.warn(
+          `Order ${positionId} not found in API after ${maxStatusRetries} status retries (API update delayed ~30s). We got position_id from creation, so order exists. Returning position_id - status will be checked in next loop iteration.`
+        );
         return {
-          position_id: result.position_id,
-          btc_exposure: openOrder.qty
+          position_id: positionId,
+          btc_exposure: amount_in_token
         };
       }
     } catch (err) {
@@ -30168,32 +30288,101 @@ var ExtendedAdapter = class _ExtendedAdapter extends BaseAdapter {
     }
   }
   async getDepositOrWithdrawalStatus(orderId, operationsType) {
-    try {
-      let transferHistory = await this.client.getAssetOperations({
-        operationsType: [operationsType],
-        operationsStatus: ["COMPLETED" /* COMPLETED */]
-      });
-      if (operationsType === "DEPOSIT" /* DEPOSIT */) {
-        const myTransferStatus = transferHistory.data.find(
-          (operation) => operation.transactionHash === orderId
-        );
-        if (!myTransferStatus) {
-          return true;
+    const maxAttempts = 5;
+    const retryDelayMs = 3e4;
+    for (let attempt = 1; attempt <= maxAttempts; attempt++) {
+      try {
+        let transferHistory = await this.client.getAssetOperations({
+          operationsType: [operationsType],
+          operationsStatus: ["COMPLETED" /* COMPLETED */]
+        });
+        if (operationsType === "DEPOSIT" /* DEPOSIT */) {
+          const myTransferStatus = transferHistory.data.find(
+            (operation) => operation.transactionHash === orderId
+          );
+          if (!myTransferStatus) {
+            if (attempt < maxAttempts) {
+              logger.info(
+                `Deposit operation not found for transactionHash ${orderId}, retrying (attempt ${attempt}/${maxAttempts})...`
+              );
+              await new Promise((resolve) => setTimeout(resolve, retryDelayMs));
+              continue;
+            }
+            logger.warn(
+              `Deposit operation not found for transactionHash ${orderId} after ${maxAttempts} attempts`
+            );
+            return false;
+          }
+          if (myTransferStatus.status === "COMPLETED" /* COMPLETED */) {
+            logger.info(
+              `Deposit operation ${orderId} completed successfully`
+            );
+            return true;
+          } else {
+            if (attempt < maxAttempts) {
+              logger.info(
+                `Deposit operation ${orderId} found but status is ${myTransferStatus.status}, not COMPLETED. Retrying (attempt ${attempt}/${maxAttempts})...`
+              );
+              await new Promise((resolve) => setTimeout(resolve, retryDelayMs));
+              continue;
+            }
+            logger.warn(
+              `Deposit operation ${orderId} status is ${myTransferStatus.status} after ${maxAttempts} attempts, expected COMPLETED`
+            );
+            return false;
+          }
+        } else {
+          const myTransferStatus = transferHistory.data.find(
+            (operation) => operation.id.toString() === orderId.toString()
+          );
+          if (!myTransferStatus) {
+            if (attempt < maxAttempts) {
+              logger.info(
+                `Withdrawal status not found for orderId ${orderId} in completed operations, retrying (attempt ${attempt}/${maxAttempts})...`
+              );
+              await new Promise((resolve) => setTimeout(resolve, retryDelayMs));
+              continue;
+            }
+            logger.warn(
+              `Withdrawal operation not found for orderId ${orderId} after ${maxAttempts} attempts`
+            );
+            return false;
+          }
+          if (myTransferStatus.status === "COMPLETED" /* COMPLETED */) {
+            logger.info(
+              `Withdrawal operation ${orderId} completed successfully`
+            );
+            return true;
+          } else {
+            if (attempt < maxAttempts) {
+              logger.info(
+                `Withdrawal operation ${orderId} found but status is ${myTransferStatus.status}, not COMPLETED. Retrying (attempt ${attempt}/${maxAttempts})...`
+              );
+              await new Promise((resolve) => setTimeout(resolve, retryDelayMs));
+              continue;
+            }
+            logger.warn(
+              `Withdrawal operation ${orderId} status is ${myTransferStatus.status} after ${maxAttempts} attempts, expected COMPLETED`
+            );
+            return false;
+          }
         }
-        return true;
-      } else {
-        const myTransferStatus = transferHistory.data.find(
-          (operation) => operation.id.toString() === orderId.toString()
+      } catch (err) {
+        logger.error(
+          `error getting deposit or withdrawal status (attempt ${attempt}/${maxAttempts}): ${err}`
         );
-        if (!myTransferStatus) {
-          return true;
+        if (attempt < maxAttempts) {
+          logger.info(`Retrying after ${retryDelayMs}ms...`);
+          await new Promise((resolve) => setTimeout(resolve, retryDelayMs));
+          continue;
         }
-        return true;
+        logger.error(
+          `Max retry attempts reached for getDepositOrWithdrawalStatus`
+        );
+        return false;
       }
-    } catch (err) {
-      logger.error(`error getting deposit or withdrawal status: ${err}`);
-      return false;
     }
+    return false;
   }
 };
 
@@ -34143,11 +34332,27 @@ var VesuExtendedMultiplierStrategy = class _VesuExtendedMultiplierStrategy exten
   }
   async shouldInvest() {
     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,
@@ -34159,10 +34364,72 @@ var VesuExtendedMultiplierStrategy = class _VesuExtendedMultiplierStrategy exten
           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,
+          vesuAmount: new Web3Number(0, 0),
+          extendedAmount: new Web3Number(0, 0),
+          extendedLeverage: 0,
+          collateralPrice: 0,
+          debtPrice: 0,
+          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
+          };
+        }
+      }
       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,
@@ -34192,6 +34459,34 @@ var VesuExtendedMultiplierStrategy = class _VesuExtendedMultiplierStrategy exten
         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(),
         extendedAdapter.client,
@@ -34242,13 +34537,45 @@ var VesuExtendedMultiplierStrategy = class _VesuExtendedMultiplierStrategy exten
     try {
       const vesuAdapter = await this.getVesuAdapter();
       const extendedAdapter = await this.getExtendedAdapter();
-      let calls = [];
       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());
+      }
+      const extendedTargetAmount = extendedAmount.abs();
+      let projectedExtendedBalance = usdcAmountOnExtendedAvailableForWithdrawal;
+      if (extendedAmount.isNegative()) {
+        projectedExtendedBalance = projectedExtendedBalance - extendedAmount.abs().toNumber();
+      }
+      const extendedAmountDifference = extendedTargetAmount.minus(projectedExtendedBalance);
+      const extendedAmountDifferenceAbs = extendedAmountDifference.abs();
+      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 = [];
       if (extendedAmount.isNegative() && extendedAmount.abs().greaterThan(extendedAdapter.minimumExtendedMovementAmount)) {
         try {
           const { calls: extendedCalls, status: extendedStatus } = await this.moveAssets(
@@ -34269,7 +34596,7 @@ var VesuExtendedMultiplierStrategy = class _VesuExtendedMultiplierStrategy exten
           logger.error(`Failed moving assets to vault: ${err}`);
         }
       }
-      if (vesuAmount.isNegative() && vesuAmount.lessThan(vesuAdapter.minimumVesuMovementAmount)) {
+      if (vesuAmount.isNegative() && vesuAmount.abs().greaterThan(vesuAdapter.minimumVesuMovementAmount)) {
         try {
           const { calls: vesuCalls, status: vesuStatus } = await this.moveAssets(
             {
@@ -34288,48 +34615,76 @@ var VesuExtendedMultiplierStrategy = class _VesuExtendedMultiplierStrategy exten
           logger.error(`Failed moving assets to vault: ${err}`);
         }
       }
-      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)) {
-        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}`);
+      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)) {
-        try {
-          const { calls: vesuCalls, status: vesuStatus } = await this.moveAssets(
-            {
-              to: Protocols.VAULT.name,
-              from: Protocols.EXTENDED.name,
-              amount: vesuAmount.minus(usdcAmountInWallet)
-            },
-            extendedAdapter,
-            vesuAdapter
+      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 {
+          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;
@@ -34340,6 +34695,38 @@ var VesuExtendedMultiplierStrategy = class _VesuExtendedMultiplierStrategy exten
   }
   async moveAssets(params, extendedAdapter, vesuAdapter) {
     try {
+      if (params.amount.lessThanOrEqualTo(0)) {
+        logger.error(
+          `Invalid amount for moveAssets: ${params.amount.toNumber()}. Amount must be positive.`
+        );
+        return {
+          calls: [],
+          status: false
+        };
+      }
+      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}`);
@@ -34400,18 +34787,18 @@ var VesuExtendedMultiplierStrategy = class _VesuExtendedMultiplierStrategy exten
           );
           if (!openLongPosition) {
             logger.error(`error opening long position: ${openLongPosition}`);
-            return {
-              calls: [],
-              status: false
-            };
           }
-          await new Promise((resolve) => setTimeout(resolve, 5e3));
+          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);
         if (withdrawalFromExtended) {
           const extendedHoldings2 = await extendedAdapter.getExtendedDepositAmount();
           logger.info(`extendedHoldings after withdrawal ${extendedHoldings2?.availableForWithdrawal}`);
-          await new Promise((resolve) => setTimeout(resolve, 1e4));
+          await new Promise((resolve) => setTimeout(resolve, 2e3));
           const calls = await this.moveAssetsToVaultAllocator(params.amount, extendedAdapter);
           if (calls.length > 0) {
             return {