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

package/dist/index.browser.global.js

@@ -93946,8 +93946,47 @@ spurious results.`);
     async withdrawFromExtended(amount) {
       try {
         if (!this.client) {
-          throw new Error("Client not initialized");
+          logger2.error("Client not initialized");
+          return false;
+        }
+        if (amount.lessThanOrEqualTo(0)) {
+          logger2.error(
+            `Invalid withdrawal amount: ${amount.toNumber()}. Amount must be positive.`
+          );
+          return false;
         }
+        if (amount.lessThanOrEqualTo(this.minimumExtendedMovementAmount)) {
+          logger2.warn(
+            `Withdrawal amount ${amount.toNumber()} is below minimum Extended movement amount ${this.minimumExtendedMovementAmount}. Skipping withdrawal.`
+          );
+          return false;
+        }
+        const holdings = await this.getExtendedDepositAmount();
+        if (!holdings) {
+          logger2.error(
+            "Cannot get holdings - unable to validate withdrawal amount"
+          );
+          return false;
+        }
+        const availableForWithdrawal = parseFloat(
+          holdings.availableForWithdrawal
+        );
+        if (!Number.isFinite(availableForWithdrawal) || availableForWithdrawal < 0) {
+          logger2.error(
+            `Invalid availableForWithdrawal: ${holdings.availableForWithdrawal}. Expected a finite, non-negative number.`
+          );
+          return false;
+        }
+        const withdrawalAmount = amount.toNumber();
+        if (withdrawalAmount > availableForWithdrawal) {
+          logger2.error(
+            `Withdrawal amount ${withdrawalAmount} exceeds available balance ${availableForWithdrawal}`
+          );
+          return false;
+        }
+        logger2.info(
+          `Withdrawing ${withdrawalAmount} from Extended. Available balance: ${availableForWithdrawal}`
+        );
         const withdrawalRequest = await this.client.withdrawUSDC(
           amount.toFixed(2)
         );
@@ -93958,6 +93997,9 @@ spurious results.`);
           );
           return withdrawalStatus;
         }
+        logger2.error(
+          `Withdrawal request failed with status: ${withdrawalRequest.status}`
+        );
         return false;
       } catch (error2) {
         logger2.error(`Error creating Withdraw Call: ${error2}`);
@@ -93968,21 +94010,44 @@ spurious results.`);
       return Promise.resolve(1);
     }
     async getExtendedDepositAmount() {
-      if (this.client === null) {
-        logger2.error("error initializing client");
-        return void 0;
-      }
-      const result2 = await this.client.getHoldings();
-      if (!result2) {
-        logger2.error(`error getting holdings: ${result2}`);
-        return void 0;
-      }
-      const holdings = result2.data;
-      if (!holdings) {
-        logger2.error(`error getting holdings: ${holdings}`);
+      try {
+        if (this.client === null) {
+          logger2.error("error initializing client - client is null");
+          return void 0;
+        }
+        const result2 = await this.client.getHoldings();
+        if (!result2) {
+          logger2.error("error getting holdings - API returned null/undefined");
+          return void 0;
+        }
+        if (result2.status && result2.status !== "OK") {
+          logger2.error(
+            `error getting holdings - API returned status: ${result2.status}`
+          );
+          return void 0;
+        }
+        const holdings = result2.data;
+        if (!holdings) {
+          logger2.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 (error2) {
+        logger2.error(`error getting holdings - exception: ${error2}`);
         return void 0;
       }
-      return holdings;
     }
     async setLeverage(leverage, marketName) {
       if (this.client === null) {
@@ -94024,38 +94089,24 @@ spurious results.`);
       return result2.data;
     }
     async getOrderStatus(orderId, marketName) {
-      if (this.client === null) {
-        logger2.error("error initializing client");
-        return null;
-      }
-      let orderhistory = await this.getOrderHistory(marketName);
-      if (!orderhistory || orderhistory.length === 0) {
-        logger2.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) {
+          logger2.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) {
-          logger2.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;
         }
-        logger2.error(
-          `order not found in top 15 entries on retry ${attempt}: ${orderId}`
-        );
+        return null;
+      } catch (error2) {
+        logger2.error(`error getting order status: ${error2}`);
+        return null;
       }
-      logger2.error(`error getting order after all retries: ${orderId}`);
-      return null;
     }
     async fetchOrderBookBTCUSDC() {
       try {
@@ -94106,14 +94157,40 @@ spurious results.`);
           logger2.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)) {
+          logger2.error(
+            `Invalid orderbook prices: ask=${ask?.toNumber()}, bid=${bid?.toNumber()}`
+          );
           return null;
         }
-        const { ask, bid } = await this.fetchOrderBookBTCUSDC();
         const spread3 = ask.minus(bid);
-        let price = ask.plus(bid).div(2);
-        side === "SELL" /* SELL */ ? price = price.minus(spread3.times(0.2 * attempt)) : price = price.plus(spread3.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 = spread3.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)) {
+          logger2.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);
+        }
+        logger2.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
         );
@@ -94124,17 +94201,57 @@ spurious results.`);
           price.toFixed(0),
           side
         );
-        if (!result2) {
+        if (!result2 || !result2.position_id) {
+          logger2.error("Failed to create order - no position_id returned");
           return null;
         }
-        await new Promise((resolve) => setTimeout(resolve, 5e3));
-        const openOrder = await this.getOrderStatus(
-          result2.position_id,
+        const positionId = result2.position_id;
+        logger2.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) {
+          logger2.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) {
+              logger2.info(
+                `Order ${positionId} found after ${statusRetry} status retry(ies)`
+              );
+              break;
+            }
+            logger2.warn(
+              `Order ${positionId} still not found after ${statusRetry}/${maxStatusRetries} status retries`
+            );
+          }
+        }
+        if (openOrder && openOrder.status === "FILLED" /* FILLED */) {
+          logger2.info(
+            `Order ${positionId} successfully filled with quantity ${openOrder.qty}`
+          );
+          return {
+            position_id: positionId,
+            btc_exposure: openOrder.qty
+          };
+        } else if (openOrder && openOrder.status !== "FILLED" /* FILLED */) {
+          logger2.warn(
+            `Order ${positionId} found but status is ${openOrder.status}, not FILLED. Retrying order creation...`
+          );
           if (attempt >= maxAttempts) {
-            logger2.error("Max retries reached \u2014 could not verify open position");
+            logger2.error(
+              `Max retries reached \u2014 order ${positionId} status is ${openOrder.status}, not FILLED`
+            );
             return null;
           } else {
             const backoff = 2e3 * attempt;
@@ -94148,9 +94265,12 @@ spurious results.`);
             );
           }
         } else {
+          logger2.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: result2.position_id,
-            btc_exposure: openOrder.qty
+            position_id: positionId,
+            btc_exposure: amount_in_token
           };
         }
       } catch (err2) {
@@ -94195,32 +94315,101 @@ spurious results.`);
       }
     }
     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) {
+                logger2.info(
+                  `Deposit operation not found for transactionHash ${orderId}, retrying (attempt ${attempt}/${maxAttempts})...`
+                );
+                await new Promise((resolve) => setTimeout(resolve, retryDelayMs));
+                continue;
+              }
+              logger2.warn(
+                `Deposit operation not found for transactionHash ${orderId} after ${maxAttempts} attempts`
+              );
+              return false;
+            }
+            if (myTransferStatus.status === "COMPLETED" /* COMPLETED */) {
+              logger2.info(
+                `Deposit operation ${orderId} completed successfully`
+              );
+              return true;
+            } else {
+              if (attempt < maxAttempts) {
+                logger2.info(
+                  `Deposit operation ${orderId} found but status is ${myTransferStatus.status}, not COMPLETED. Retrying (attempt ${attempt}/${maxAttempts})...`
+                );
+                await new Promise((resolve) => setTimeout(resolve, retryDelayMs));
+                continue;
+              }
+              logger2.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) {
+                logger2.info(
+                  `Withdrawal status not found for orderId ${orderId} in completed operations, retrying (attempt ${attempt}/${maxAttempts})...`
+                );
+                await new Promise((resolve) => setTimeout(resolve, retryDelayMs));
+                continue;
+              }
+              logger2.warn(
+                `Withdrawal operation not found for orderId ${orderId} after ${maxAttempts} attempts`
+              );
+              return false;
+            }
+            if (myTransferStatus.status === "COMPLETED" /* COMPLETED */) {
+              logger2.info(
+                `Withdrawal operation ${orderId} completed successfully`
+              );
+              return true;
+            } else {
+              if (attempt < maxAttempts) {
+                logger2.info(
+                  `Withdrawal operation ${orderId} found but status is ${myTransferStatus.status}, not COMPLETED. Retrying (attempt ${attempt}/${maxAttempts})...`
+                );
+                await new Promise((resolve) => setTimeout(resolve, retryDelayMs));
+                continue;
+              }
+              logger2.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 (err2) {
+          logger2.error(
+            `error getting deposit or withdrawal status (attempt ${attempt}/${maxAttempts}): ${err2}`
           );
-          if (!myTransferStatus) {
-            return true;
+          if (attempt < maxAttempts) {
+            logger2.info(`Retrying after ${retryDelayMs}ms...`);
+            await new Promise((resolve) => setTimeout(resolve, retryDelayMs));
+            continue;
           }
-          return true;
+          logger2.error(
+            `Max retry attempts reached for getDepositOrWithdrawalStatus`
+          );
+          return false;
         }
-      } catch (err2) {
-        logger2.error(`error getting deposit or withdrawal status: ${err2}`);
-        return false;
       }
+      return false;
     }
   };
 
@@ -98165,11 +98354,27 @@ spurious results.`);
     }
     async shouldInvest() {
       try {
+        logger2.info(`${_VesuExtendedMultiplierStrategy.name}::shouldInvest starting`);
         const vesuAdapter = await this.getVesuAdapter();
         const extendedAdapter = await this.getExtendedAdapter();
-        if (!vesuAdapter || !extendedAdapter || !extendedAdapter.client) {
+        logger2.info(`${_VesuExtendedMultiplierStrategy.name}::shouldInvest adapters fetched: vesuAdapter=${!!vesuAdapter}, extendedAdapter=${!!extendedAdapter}, extendedAdapter.client=${!!extendedAdapter?.client}`);
+        if (!vesuAdapter) {
           logger2.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) {
+          logger2.error(
+            `Extended adapter not configured in metadata. This is a configuration issue, not a temporary failure.`
           );
           return {
             shouldInvest: false,
@@ -98181,10 +98386,72 @@ spurious results.`);
             vesuLeverage: 0
           };
         }
+        if (!extendedAdapter.client) {
+          logger2.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
+          };
+        }
+        logger2.info(`${_VesuExtendedMultiplierStrategy.name}::shouldInvest calling getUnusedBalance`);
         const balance = await this.getUnusedBalance();
+        if (!Number.isFinite(balance.usdValue) || balance.usdValue < 0) {
+          logger2.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
+          };
+        }
+        logger2.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) {
+            logger2.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);
-        logger2.info(`${_VesuExtendedMultiplierStrategy.name}::shouldInvest amountToInvest: ${amountToInvest.toNumber()}`);
+        const amountToInvestNumber = amountToInvest.toNumber();
+        if (!Number.isFinite(amountToInvestNumber)) {
+          logger2.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
+          };
+        }
+        logger2.info(`${_VesuExtendedMultiplierStrategy.name}::shouldInvest amountToInvest: ${amountToInvestNumber}`);
         if (amountToInvest.lessThan(0)) {
           return {
             shouldInvest: false,
@@ -98214,6 +98481,34 @@ spurious results.`);
           collateralPrice,
           debtPrice
         } = await this.getAssetPrices();
+        if (!Number.isFinite(collateralPrice.price) || collateralPrice.price <= 0) {
+          logger2.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) {
+          logger2.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,
@@ -98264,13 +98559,45 @@ spurious results.`);
       try {
         const vesuAdapter = await this.getVesuAdapter();
         const extendedAdapter = await this.getExtendedAdapter();
-        let calls = [];
         if (!vesuAdapter || !extendedAdapter || !extendedAdapter.client) {
           logger2.error(
             `vesu or extended adapter not found: vesuAdapter=${vesuAdapter}, extendedAdapter=${extendedAdapter}`
           );
-          return calls;
+          return [];
+        }
+        const extendedHoldings = await extendedAdapter.getExtendedDepositAmount();
+        if (!extendedHoldings) {
+          logger2.error(`error getting extended holdings: ${extendedHoldings}`);
+          return [];
         }
+        const usdcAmountInWallet = (await this.getUnusedBalance()).amount;
+        const usdcAmountOnExtendedAvailableForWithdrawal = parseFloat(
+          extendedHoldings.availableForWithdrawal
+        );
+        logger2.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();
+        logger2.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(
@@ -98291,7 +98618,7 @@ spurious results.`);
             logger2.error(`Failed moving assets to vault: ${err2}`);
           }
         }
-        if (vesuAmount.isNegative() && vesuAmount.lessThan(vesuAdapter.minimumVesuMovementAmount)) {
+        if (vesuAmount.isNegative() && vesuAmount.abs().greaterThan(vesuAdapter.minimumVesuMovementAmount)) {
           try {
             const { calls: vesuCalls, status: vesuStatus } = await this.moveAssets(
               {
@@ -98310,48 +98637,76 @@ spurious results.`);
             logger2.error(`Failed moving assets to vault: ${err2}`);
           }
         }
-        const extendedHoldings = await extendedAdapter.getExtendedDepositAmount();
-        if (!extendedHoldings) {
-          logger2.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 (err2) {
-            logger2.error(`Failed moving assets to extended: ${err2}`);
+        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 {
+                logger2.error(`Failed to move assets to extended - operation returned false status`);
+                return [];
+              }
+            } catch (err2) {
+              logger2.error(`Failed moving assets to extended: ${err2}`);
+              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 {
+                logger2.error(`Failed to withdraw from extended - operation returned false status`);
+                return [];
+              }
+            } catch (err2) {
+              logger2.error(`Failed moving assets from extended to vault: ${err2}`);
+              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)) {
+            logger2.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) {
+                logger2.error(`Failed to move assets to vesu - operation returned false status`);
+                return [];
+              }
+              calls.push(...vesuCalls);
+            } catch (err2) {
+              logger2.error(`Failed moving assets to vault: ${err2}`);
               return [];
             }
-            calls.push(...vesuCalls);
-          } catch (err2) {
-            logger2.error(`Failed moving assets to vault: ${err2}`);
           }
         }
         return calls;
@@ -98362,6 +98717,38 @@ spurious results.`);
     }
     async moveAssets(params, extendedAdapter, vesuAdapter) {
       try {
+        if (params.amount.lessThanOrEqualTo(0)) {
+          logger2.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)) {
+            logger2.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)) {
+            logger2.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) {
           logger2.error(`avnu adapter not found: ${avnuAdapter}`);
@@ -98422,18 +98809,18 @@ spurious results.`);
             );
             if (!openLongPosition) {
               logger2.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())) {
+              logger2.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();
             logger2.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 {